>, "O", "X")
87 | %Guilda.Accounts.UserTOTP.BackupCode{code: code}
88 | end
89 | end
90 | end
91 |
--------------------------------------------------------------------------------
/lib/guilda/application.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Application do
2 | # See https://hexdocs.pm/elixir/Application.html
3 | # for more information on OTP Applications
4 | @moduledoc false
5 |
6 | use Application
7 |
8 | def start(_type, _args) do
9 | children = [
10 | # Start the Ecto repository
11 | Guilda.Repo,
12 | # Start the Telemetry supervisor
13 | GuildaWeb.Telemetry,
14 | # Start the PubSub system
15 | {Phoenix.PubSub, name: Guilda.PubSub},
16 | # Start presence
17 | GuildaWeb.Presence,
18 | # Start the Endpoint (http/https)
19 | GuildaWeb.Endpoint,
20 | # Start a worker by calling: Guilda.Worker.start_link(arg)
21 | # {Guilda.Worker, arg}
22 | # {Guilda.Bot, guilda_bot_config()}
23 | {Finch, name: Swoosh.Finch},
24 | ExGram,
25 | {Guilda.Bot, guilda_bot_config()}
26 | ]
27 |
28 | # See https://hexdocs.pm/elixir/Supervisor.html
29 | # for other strategies and supported options
30 | opts = [strategy: :one_for_one, name: Guilda.Supervisor]
31 | Supervisor.start_link(children, opts)
32 | end
33 |
34 | # Tell Phoenix to update the endpoint configuration
35 | # whenever the application is updated.
36 | def config_change(changed, _new, removed) do
37 | GuildaWeb.Endpoint.config_change(changed, removed)
38 | :ok
39 | end
40 |
41 | if Application.compile_env(:guilda, :environment) == :test do
42 | def guilda_bot_config do
43 | [method: :noup, token: "token"]
44 | end
45 | else
46 | def guilda_bot_config do
47 | case Application.fetch_env!(:guilda, :auth)[:telegram_bot_token] do
48 | nil -> [method: :noup, token: "token"]
49 | token -> [method: :polling, token: token]
50 | end
51 | end
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/lib/guilda/bot.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Bot do
2 | @moduledoc """
3 | Our bot used to store the user's location.
4 | """
5 | @bot :guilda
6 | use ExGram.Bot,
7 | name: @bot,
8 | setup_commands: true
9 |
10 | import GuildaWeb.Gettext
11 | alias Guilda.Accounts
12 | alias Guilda.Accounts.User
13 | alias Guilda.AuditLog
14 | require Logger
15 |
16 | command("start")
17 | command("help", description: "Mostra os comandos do bot.")
18 |
19 | middleware(ExGram.Middleware.IgnoreUsername)
20 |
21 | def bot, do: @bot
22 |
23 | def handle({:command, :start, _msg}, context) do
24 | answer(context, "Olá!")
25 | end
26 |
27 | def handle({:command, :help, _msg}, context) do
28 | answer(
29 | context,
30 | """
31 | Eu sou o bot da @guildatech!
32 |
33 | Por enquanto eu não respondo a nenhum comando, mas você pode me enviar sua localização para aparecer no nosso mapa de participantes!
34 |
35 | Para isso, basta apenas me enviar sua localização usando o seu celular.
36 |
37 | Para ver quem já compartilhou a localização acesse https://guildatech.com/members.
38 | """
39 | )
40 | end
41 |
42 | def handle({:location, %{latitude: lat, longitude: lng}}, context) do
43 | from = context.update.message.from
44 |
45 | with {:user, %User{} = user} <- {:user, Accounts.get_user_by_telegram_id(Kernel.to_string(from.id))},
46 | {:location, {:ok, _user}} <- {:location, Accounts.set_lng_lat(AuditLog.system(), user, lng, lat)} do
47 | answer(
48 | context,
49 | gettext("Your location has been saved successfully! See the map at https://guildatech.com/members.")
50 | )
51 | else
52 | {:user, nil} ->
53 | answer(
54 | context,
55 | gettext(
56 | "You don't have an account yet. Please register at https://guildatech.com/users/register, confirm your email address and link your Telegram account."
57 | )
58 | )
59 |
60 | {:location, {:error, _changeset}} ->
61 | answer(context, gettext("Unable to save your location."))
62 | end
63 | end
64 | end
65 |
--------------------------------------------------------------------------------
/lib/guilda/extensions/ecto/ip_address.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Extensions.Ecto.IPAddress do
2 | @moduledoc false
3 | use Ecto.Type
4 |
5 | @impl true
6 | def type, do: :inet
7 |
8 | @impl true
9 | def cast(string) when is_binary(string) do
10 | parts = String.split(string, ".")
11 |
12 | case Enum.map(parts, &Integer.parse/1) do
13 | [{a, ""}, {b, ""}, {c, ""}, {d, ""}]
14 | when a in 0..255 and b in 0..255 and c in 0..255 and d in 0..255 ->
15 | {:ok, {a, b, c, d}}
16 |
17 | _ ->
18 | :error
19 | end
20 | end
21 |
22 | def cast(_), do: :error
23 |
24 | @impl true
25 | def dump({_, _, _, _} = address), do: {:ok, %Postgrex.INET{address: address}}
26 | def dump(_), do: :error
27 |
28 | @impl true
29 | def load(%Postgrex.INET{} = struct), do: {:ok, struct.address}
30 | def load(_), do: :error
31 | end
32 |
--------------------------------------------------------------------------------
/lib/guilda/finances/policy.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Finances.Policy do
2 | @moduledoc """
3 | Authorization policy for the Finances context.
4 | """
5 | @behaviour Bodyguard.Policy
6 |
7 | alias Guilda.Accounts.User
8 |
9 | def authorize(:create_transaction, %User{is_admin: true}, _params), do: true
10 |
11 | def authorize(:update_transaction, %User{is_admin: true}, _params), do: true
12 |
13 | def authorize(:delete_transaction, %User{is_admin: true}, _params), do: true
14 |
15 | def authorize(:manage_transaction, %User{is_admin: true}, _params), do: true
16 |
17 | def authorize(_action, _user, _params),
18 | do: {:error, Err.wrap(mod: GuildaWeb.UserAuth, reason: :unauthorized)}
19 | end
20 |
--------------------------------------------------------------------------------
/lib/guilda/finances/transaction.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Finances.Transaction do
2 | @moduledoc """
3 | Transaction schema.
4 | """
5 | use Ecto.Schema
6 | import Ecto.Changeset
7 |
8 | @primary_key {:id, :binary_id, autogenerate: true}
9 | @foreign_key_type :binary_id
10 | schema "transactions" do
11 | field :amount, :decimal, default: Decimal.new(0)
12 | field :date, :date
13 | field :note, :string
14 | field :payee, :string
15 | field :transaction_type, Ecto.Enum, values: ~w(inflow outflow)a, default: :inflow, virtual: true
16 |
17 | field :toggle, :boolean, default: false, virtual: true
18 |
19 | timestamps()
20 | end
21 |
22 | @doc false
23 | def changeset(transaction, attrs) do
24 | transaction
25 | |> cast(attrs, [:date, :toggle, :amount, :payee, :note])
26 | |> validate_required([:date, :amount, :payee])
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/lib/guilda/geo.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Geo do
2 | @moduledoc """
3 | A module used to add an error margin to coordinates.
4 | """
5 |
6 | @doc """
7 | Returns a random lat/lng coordinate within the given radius
8 | of a location.
9 |
10 | Adapted from https://gis.stackexchange.com/questions/25877/generating-random-locations-nearby
11 |
12 | ## Example
13 |
14 | iex> random_nearby_lng_lat(39.74, -104.99, 3)
15 | {39.7494, -105.0014}
16 | """
17 | def random_nearby_lng_lat(lng, lat, radiusKm, precision \\ 3) do
18 | radius_rad = radiusKm / 111.3
19 |
20 | u = :rand.uniform()
21 | v = :rand.uniform()
22 |
23 | w = radius_rad * :math.sqrt(u)
24 | t = 2 * :math.pi() * v
25 |
26 | x = w * :math.cos(t)
27 | y1 = w * :math.sin(t)
28 |
29 | # Adjust the x-coordinate for the shrinking
30 | # of the east-west distances
31 | lat_rads = lat / (180 / :math.pi())
32 | x1 = x / :math.cos(lat_rads)
33 |
34 | new_lng = Float.round(lng + x1, precision)
35 | new_lat = Float.round(lat + y1, precision)
36 |
37 | {new_lng, new_lat}
38 | end
39 | end
40 |
--------------------------------------------------------------------------------
/lib/guilda/mailer.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Mailer do
2 | @moduledoc false
3 | use Swoosh.Mailer, otp_app: :guilda
4 | end
5 |
--------------------------------------------------------------------------------
/lib/guilda/podcasts/episode.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Podcasts.Episode do
2 | @moduledoc """
3 | Podcasts Episode schema.
4 | """
5 | use Ecto.Schema
6 | import Ecto.Changeset
7 |
8 | @primary_key {:id, :binary_id, autogenerate: true}
9 | @foreign_key_type :binary_id
10 | schema "podcast_episodes" do
11 | field :title, :string
12 | field :slug, :string
13 | field :description, :string
14 | field :hosts, :string
15 | field :aired_date, :date
16 | field :cover_url, :string
17 | field :cover_name, :string
18 | field :cover_type, :string
19 | field :cover_size, :integer
20 | field :file_url, :string
21 | field :file_name, :string
22 | field :file_type, :string
23 | field :file_size, :integer
24 | field :length, :integer, default: 0
25 | field :play_count, :integer, default: 0
26 |
27 | timestamps()
28 | end
29 |
30 | @changeset_attrs ~w(aired_date title description hosts slug cover_url cover_name cover_type cover_size file_url
31 | file_name file_type file_size length)a
32 |
33 | def changeset(episode, attrs) do
34 | episode
35 | |> cast(attrs, @changeset_attrs)
36 | |> validate_required(@changeset_attrs)
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/lib/guilda/podcasts/policy.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Podcasts.Policy do
2 | @moduledoc """
3 | Authorization policy for the Podcasts context.
4 | """
5 | @behaviour Bodyguard.Policy
6 |
7 | alias Guilda.Accounts.User
8 |
9 | def authorize(:create_episode, %User{is_admin: true}, _params), do: true
10 |
11 | def authorize(:update_episode, %User{is_admin: true}, _params), do: true
12 |
13 | def authorize(:delete_episode, %User{is_admin: true}, _params), do: true
14 |
15 | def authorize(_action, _user, _params),
16 | do: {:error, Err.wrap(mod: GuildaWeb.UserAuth, reason: :unauthorized)}
17 | end
18 |
--------------------------------------------------------------------------------
/lib/guilda/postgres_types.ex:
--------------------------------------------------------------------------------
1 | Postgrex.Types.define(
2 | Guilda.PostgresTypes,
3 | [Geo.PostGIS.Extension] ++ Ecto.Adapters.Postgres.extensions()
4 | )
5 |
--------------------------------------------------------------------------------
/lib/guilda/release.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Release do
2 | @moduledoc """
3 | Used for executing DB release tasks when run in production without Mix
4 | installed.
5 | """
6 | @app :guilda
7 |
8 | def migrate do
9 | load_app()
10 |
11 | for repo <- repos() do
12 | {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true))
13 | end
14 | end
15 |
16 | def rollback(repo, version) do
17 | load_app()
18 | {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
19 | end
20 |
21 | defp repos do
22 | Application.fetch_env!(@app, :ecto_repos)
23 | end
24 |
25 | defp load_app do
26 | Application.load(@app)
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/lib/guilda/repo.ex:
--------------------------------------------------------------------------------
1 | defmodule Guilda.Repo do
2 | use Ecto.Repo,
3 | otp_app: :guilda,
4 | adapter: Ecto.Adapters.Postgres
5 | end
6 |
--------------------------------------------------------------------------------
/lib/guilda_web.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb do
2 | @moduledoc """
3 | The entrypoint for defining your web interface, such
4 | as controllers, views, channels and so on.
5 |
6 | This can be used in your application as:
7 |
8 | use GuildaWeb, :controller
9 | use GuildaWeb, :view
10 |
11 | The definitions below will be executed for every view,
12 | controller, etc, so keep them short and clean, focused
13 | on imports, uses and aliases.
14 |
15 | Do NOT define functions inside the quoted expressions
16 | below. Instead, define any helper function in modules
17 | and import those modules here.
18 | """
19 |
20 | def controller do
21 | quote do
22 | use Phoenix.Controller, namespace: GuildaWeb
23 |
24 | import Plug.Conn
25 | import GuildaWeb.Gettext
26 | alias GuildaWeb.Router.Helpers, as: Routes
27 | end
28 | end
29 |
30 | def view do
31 | quote do
32 | use Phoenix.View,
33 | root: "lib/guilda_web/templates",
34 | namespace: GuildaWeb
35 |
36 | use Phoenix.Component
37 |
38 | # Import convenience functions from controllers
39 | import Phoenix.Controller,
40 | only: [get_flash: 1, get_flash: 2, view_module: 1, view_template: 1]
41 |
42 | # Include shared imports and aliases for views
43 | unquote(view_helpers())
44 | end
45 | end
46 |
47 | def live_view(opts \\ []) do
48 | quote do
49 | opts = Keyword.merge([layout: {GuildaWeb.LayoutView, :live}], unquote(opts))
50 | use Phoenix.LiveView, opts
51 |
52 | def handle_info({:flash, key, message}, socket) do
53 | {:noreply, put_flash(socket, key, message)}
54 | end
55 |
56 | unquote(view_helpers())
57 | end
58 | end
59 |
60 | def live_component do
61 | quote do
62 | use Phoenix.LiveComponent
63 |
64 | unquote(view_helpers())
65 | end
66 | end
67 |
68 | def router do
69 | quote do
70 | use Phoenix.Router
71 |
72 | import Plug.Conn
73 | import Phoenix.Controller
74 | import Phoenix.LiveView.Router
75 | end
76 | end
77 |
78 | defp view_helpers do
79 | quote do
80 | # Use all HTML functionality (forms, tags, etc)
81 | use Phoenix.HTML
82 |
83 | # Import basic rendering functionality (render, render_layout, etc)
84 | import Phoenix.View
85 |
86 | import GuildaWeb.Components
87 | import GuildaWeb.Components.Badge
88 | import GuildaWeb.Components.Button
89 | import GuildaWeb.Components.Dialog
90 | import GuildaWeb.Gettext
91 |
92 | alias GuildaWeb.Icons
93 | alias GuildaWeb.Router.Helpers, as: Routes
94 | alias Phoenix.LiveView.JS
95 | end
96 | end
97 |
98 | @doc """
99 | When used, dispatch to the appropriate controller/view/etc.
100 | """
101 | defmacro __using__({which, opts}) when is_atom(which) do
102 | apply(__MODULE__, which, [opts])
103 | end
104 |
105 | defmacro __using__(which) when is_atom(which) do
106 | apply(__MODULE__, which, [])
107 | end
108 | end
109 |
--------------------------------------------------------------------------------
/lib/guilda_web/channels/presence.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.Presence do
2 | @moduledoc """
3 | Provides presence tracking to channels and processes.
4 |
5 | See the [`Phoenix.Presence`](https://hexdocs.pm/phoenix/Phoenix.Presence.html)
6 | docs for more details.
7 | """
8 | use Phoenix.Presence,
9 | otp_app: :guilda,
10 | pubsub_server: Guilda.PubSub,
11 | presence: __MODULE__
12 |
13 | @pubsub Guilda.PubSub
14 |
15 | def track_user(current_user_id) do
16 | track(
17 | self(),
18 | "proxy:" <> topic(),
19 | current_user_id,
20 | %{}
21 | )
22 | end
23 |
24 | def untrack_user(current_user_id) do
25 | untrack(
26 | self(),
27 | "proxy:" <> topic(),
28 | current_user_id
29 | )
30 | end
31 |
32 | def init(_opts) do
33 | {:ok, %{}}
34 | end
35 |
36 | def handle_metas(topic, %{joins: joins, leaves: leaves}, presences, state) do
37 | for {user_id, presence} <- joins do
38 | user_data = %{user: presence.user, metas: Map.fetch!(presences, user_id)}
39 | broadcast(topic, {__MODULE__, %{user_joined: user_data}})
40 | end
41 |
42 | for {user_id, presence} <- leaves do
43 | metas =
44 | case Map.fetch(presences, user_id) do
45 | {:ok, presence_metas} -> presence_metas
46 | :error -> []
47 | end
48 |
49 | user_data = %{user: presence.user, metas: metas}
50 |
51 | broadcast(topic, {__MODULE__, %{user_left: user_data}})
52 | end
53 |
54 | {:ok, state}
55 | end
56 |
57 | def subscribe_to_online_users do
58 | Phoenix.PubSub.subscribe(@pubsub, "proxy:" <> topic())
59 | end
60 |
61 | def list_users(topic) do
62 | list("proxy:" <> topic)
63 | end
64 |
65 | def fetch(_topic, presences) do
66 | for {key, %{metas: metas}} <- presences, into: %{} do
67 | {key, %{metas: metas, user: key}}
68 | end
69 | end
70 |
71 | defp topic do
72 | "online_users"
73 | end
74 |
75 | defp broadcast("proxy:" <> topic, payload) do
76 | Phoenix.PubSub.broadcast(@pubsub, topic, payload)
77 | end
78 | end
79 |
--------------------------------------------------------------------------------
/lib/guilda_web/components/helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.Components.Helpers do
2 | @moduledoc """
3 | Provides general helpers used in components.
4 | """
5 |
6 | @doc """
7 | Remove newlines and extra spaces from a string
8 | """
9 | def convert_string_to_one_line(string) when is_binary(string) do
10 | string
11 | |> String.replace("\r", " ")
12 | |> String.replace("\n", " ")
13 | |> String.split()
14 | |> Enum.join(" ")
15 | end
16 | end
17 |
--------------------------------------------------------------------------------
/lib/guilda_web/controllers/auth_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.AuthController do
2 | use GuildaWeb, :controller
3 |
4 | alias Guilda.Accounts
5 | alias GuildaWeb.UserAuth
6 |
7 | # credo:disable-for-next-line
8 | def telegram_callback(conn, params) do
9 | case verify_telegram_data(params, get_session(conn, :telegram_bot_token)) do
10 | {:ok, params} ->
11 | user = conn.assigns.current_user
12 | user_from_telegram_params = Accounts.get_user_by_telegram_id(params["telegram_id"])
13 |
14 | cond do
15 | user && user.telegram_id ->
16 | # User is signed in and already connected a Telegram account
17 | conn
18 | |> put_flash(:error, gettext("You already connected a Telegram account."))
19 | |> redirect(to: Routes.user_settings_path(conn, :index))
20 |
21 | user && !user_from_telegram_params ->
22 | # User is signed in and there's no other account with the same Telegram ID
23 | # credo:disable-for-next-line
24 | case Accounts.connect_provider(conn.assigns.audit_context, user, :telegram, params["telegram_id"]) do
25 | {:ok, _user} ->
26 | conn
27 | |> put_flash(:info, gettext("Successfully connected your Telegram account."))
28 | |> redirect(to: Routes.user_settings_path(conn, :index))
29 |
30 | _ ->
31 | conn
32 | |> put_flash(:error, gettext("Failed to connect your Telegram account."))
33 | |> redirect(to: Routes.user_settings_path(conn, :index))
34 | end
35 |
36 | !user && user_from_telegram_params ->
37 | # User is not signed in and there is an account for the given Telegram ID
38 | conn
39 | |> UserAuth.log_in_user(user_from_telegram_params)
40 | |> UserAuth.redirect_user_after_login()
41 |
42 | true ->
43 | # User is not signed in and there is no account for the given Telegram ID
44 | conn
45 | |> put_flash(:error, gettext("You must register or sign in before connecting a Telegram account."))
46 | |> redirect(to: Routes.user_registration_path(conn, :new))
47 | end
48 |
49 | _ ->
50 | conn
51 | |> put_flash(:error, gettext("Unable to authenticate. Please try again later."))
52 | |> redirect(to: Routes.home_path(conn, :index))
53 | end
54 | end
55 |
56 | def telegram_bot_username do
57 | Application.fetch_env!(:guilda, :auth)[:telegram_bot_username]
58 | end
59 |
60 | def telegram_bot_token do
61 | Application.fetch_env!(:guilda, :auth)[:telegram_bot_token]
62 | end
63 |
64 | if Application.compile_env(:guilda, :environment) == :dev do
65 | def verify_telegram_data(params, _token \\ nil) do
66 | {:ok, Map.put(params, "telegram_id", params["id"])}
67 | end
68 | else
69 | def verify_telegram_data(params, token \\ nil) do
70 | {hash, params} = Map.pop(params, "hash")
71 |
72 | secret_key = :crypto.hash(:sha256, token || telegram_bot_token())
73 |
74 | data_check_string = Enum.map_join(params, "\n", fn {k, v} -> "#{k}=#{v}" end)
75 |
76 | hmac = :crypto.mac(:hmac, :sha256, secret_key, data_check_string) |> Base.encode16(case: :lower)
77 |
78 | if hmac == hash do
79 | {:ok, Map.put(params, "telegram_id", params["id"])}
80 | else
81 | {:error, :invalid_telegram_data}
82 | end
83 | end
84 | end
85 | end
86 |
--------------------------------------------------------------------------------
/lib/guilda_web/controllers/feed_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.FeedController do
2 | use GuildaWeb, :controller
3 |
4 | alias Guilda.Podcasts
5 |
6 | def index(conn, _params) do
7 | render(conn, "index.xml", episodes: Podcasts.list_podcast_episodes())
8 | end
9 | end
10 |
--------------------------------------------------------------------------------
/lib/guilda_web/controllers/user_confirmation_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.UserConfirmationController do
2 | use GuildaWeb, :controller
3 |
4 | alias Guilda.Accounts
5 |
6 | def new(conn, _params) do
7 | render(conn, "new.html")
8 | end
9 |
10 | def create(conn, %{"user" => %{"email" => email}}) do
11 | if user = Accounts.get_user_by_email(email) do
12 | Accounts.deliver_user_confirmation_instructions(
13 | user,
14 | &Routes.user_confirmation_url(conn, :edit, &1)
15 | )
16 | end
17 |
18 | conn
19 | |> put_flash(
20 | :info,
21 | gettext(
22 | "If your email is in our system and it has not been confirmed yet, you will receive an email with instructions shortly."
23 | )
24 | )
25 | |> redirect(to: "/")
26 | end
27 |
28 | def edit(conn, %{"token" => token}) do
29 | render(conn, "edit.html", token: token)
30 | end
31 |
32 | # Do not log in the user after confirmation to avoid a
33 | # leaked token giving the user access to the account.
34 | def update(conn, %{"token" => token}) do
35 | case Accounts.confirm_user(token) do
36 | {:ok, _} ->
37 | conn
38 | |> put_flash(:info, "Account confirmed successfully.")
39 | |> redirect(to: "/")
40 |
41 | :error ->
42 | # If there is a current user and the account was already confirmed,
43 | # then odds are that the confirmation link was already visited, either
44 | # by some automation or by the user themselves, so we redirect without
45 | # a warning message.
46 | case conn.assigns do
47 | %{current_user: %{confirmed_at: confirmed_at}} when not is_nil(confirmed_at) ->
48 | redirect(conn, to: "/")
49 |
50 | %{} ->
51 | conn
52 | |> put_flash(:error, "Account confirmation link is invalid or it has expired.")
53 | |> redirect(to: "/")
54 | end
55 | end
56 | end
57 | end
58 |
--------------------------------------------------------------------------------
/lib/guilda_web/controllers/user_registration_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.UserRegistrationController do
2 | use GuildaWeb, :controller
3 |
4 | alias Guilda.Accounts
5 | alias Guilda.Accounts.User
6 | alias GuildaWeb.UserAuth
7 |
8 | def new(conn, _params) do
9 | changeset = Accounts.change_user_registration(%User{})
10 | render(conn, "new.html", changeset: changeset)
11 | end
12 |
13 | def create(conn, %{"user" => user_params}) do
14 | case Accounts.register_user(conn.assigns.audit_context, user_params) do
15 | {:ok, user} ->
16 | {:ok, _} =
17 | Accounts.deliver_user_confirmation_instructions(
18 | user,
19 | &Routes.user_confirmation_url(conn, :edit, &1)
20 | )
21 |
22 | conn
23 | |> put_flash(:info, "Account created successfully.")
24 | |> UserAuth.log_in_user(user)
25 | |> UserAuth.redirect_user_after_login()
26 |
27 | {:error, %Ecto.Changeset{} = changeset} ->
28 | render(conn, "new.html", changeset: changeset)
29 | end
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/lib/guilda_web/controllers/user_reset_password_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.UserResetPasswordController do
2 | use GuildaWeb, :controller
3 |
4 | alias Guilda.Accounts
5 |
6 | plug :get_user_by_reset_password_token when action in [:edit, :update]
7 |
8 | def new(conn, _params) do
9 | render(conn, "new.html")
10 | end
11 |
12 | def create(conn, %{"user" => %{"email" => email}}) do
13 | if user = Accounts.get_user_by_email(email) do
14 | Accounts.deliver_user_reset_password_instructions(
15 | conn.assigns.audit_context,
16 | user,
17 | &Routes.user_reset_password_url(conn, :edit, &1)
18 | )
19 | end
20 |
21 | conn
22 | |> put_flash(
23 | :info,
24 | "If your email is in our system, you will receive instructions to reset your password shortly."
25 | )
26 | |> redirect(to: "/")
27 | end
28 |
29 | def edit(conn, _params) do
30 | render(conn, "edit.html", changeset: Accounts.change_user_password(conn.assigns.user))
31 | end
32 |
33 | # Do not log in the user after reset password to avoid a
34 | # leaked token giving the user access to the account.
35 | def update(conn, %{"user" => user_params}) do
36 | case Accounts.reset_user_password(conn.assigns.audit_context, conn.assigns.user, user_params) do
37 | {:ok, _} ->
38 | conn
39 | |> put_flash(:info, "Password reset successfully.")
40 | |> redirect(to: Routes.user_session_path(conn, :new))
41 |
42 | {:error, changeset} ->
43 | render(conn, "edit.html", changeset: changeset)
44 | end
45 | end
46 |
47 | defp get_user_by_reset_password_token(conn, _opts) do
48 | %{"token" => token} = conn.params
49 |
50 | if user = Accounts.get_user_by_reset_password_token(token) do
51 | conn |> assign(:user, user) |> assign(:token, token)
52 | else
53 | conn
54 | |> put_flash(:error, "Reset password link is invalid or it has expired.")
55 | |> redirect(to: "/")
56 | |> halt()
57 | end
58 | end
59 | end
60 |
--------------------------------------------------------------------------------
/lib/guilda_web/controllers/user_session_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.UserSessionController do
2 | use GuildaWeb, :controller
3 |
4 | alias Guilda.Accounts
5 | alias Guilda.AuditLog
6 | alias GuildaWeb.UserAuth
7 |
8 | def new(conn, _params) do
9 | render(conn, "new.html", error_message: nil)
10 | end
11 |
12 | def create(conn, %{"user" => user_params}) do
13 | %{"email" => email, "password" => password} = user_params
14 |
15 | if user = Accounts.get_user_by_email_and_password(email, password) do
16 | audit_context = %{conn.assigns.audit_context | user: user}
17 | AuditLog.audit!(audit_context, "accounts.login", %{email: email})
18 | conn = UserAuth.log_in_user(conn, user)
19 |
20 | if Accounts.get_user_totp(user) do
21 | totp_params = Map.take(user_params, ["remember_me"])
22 |
23 | conn
24 | |> put_session(:user_totp_pending, true)
25 | |> redirect(to: Routes.user_totp_path(conn, :new, user: totp_params))
26 | else
27 | UserAuth.redirect_user_after_login(conn, user_params)
28 | end
29 | else
30 | # In order to prevent user enumeration attacks, don't disclose whether the email is registered.
31 | render(conn, "new.html", error_message: gettext("Invalid email or password"))
32 | end
33 | end
34 |
35 | def delete(conn, _params) do
36 | conn
37 | |> put_flash(:info, "Signed out successfully.")
38 | |> UserAuth.log_out_user()
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/lib/guilda_web/controllers/user_settings_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.UserSettingsController do
2 | use GuildaWeb, :controller
3 |
4 | alias Guilda.Accounts
5 | alias GuildaWeb.UserAuth
6 |
7 | def confirm_email(conn, %{"token" => token}) do
8 | case Accounts.update_user_email(conn.assigns.audit_context, conn.assigns.current_user, token) do
9 | :ok ->
10 | conn
11 | |> put_flash(:info, gettext("Email changed successfully."))
12 | |> redirect(to: Routes.user_settings_path(conn, :index))
13 |
14 | :error ->
15 | conn
16 | |> put_flash(:error, gettext("Email change link is invalid or it has expired."))
17 | |> redirect(to: Routes.user_settings_path(conn, :index))
18 | end
19 | end
20 |
21 | def update_password(conn, %{"current_password" => password, "user" => user_params}) do
22 | user = conn.assigns.current_user
23 |
24 | case Accounts.update_user_password(conn.assigns.audit_context, user, password, user_params) do
25 | {:ok, user} ->
26 | conn
27 | |> put_flash(:info, gettext("Password updated successfully."))
28 | |> put_session(:user_return_to, Routes.user_settings_path(conn, :index))
29 | |> UserAuth.log_in_user(user)
30 |
31 | _ ->
32 | conn
33 | |> put_flash(:error, gettext("We were unable to update your password. Please try again."))
34 | |> redirect(to: Routes.user_settings_path(conn, :index))
35 | end
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/lib/guilda_web/controllers/user_totp_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.UserTOTPController do
2 | use GuildaWeb, :controller
3 |
4 | alias Guilda.Accounts
5 | alias GuildaWeb.UserAuth
6 |
7 | plug :redirect_if_totp_is_not_pending
8 |
9 | @pending :user_totp_pending
10 |
11 | def new(conn, _params) do
12 | render(conn, "new.html", error_message: nil)
13 | end
14 |
15 | def create(conn, %{"user" => user_params}) do
16 | audit_context = conn.assigns.audit_context
17 | current_user = conn.assigns.current_user
18 |
19 | case Accounts.validate_user_totp(audit_context, current_user, user_params["code"]) do
20 | :valid_totp ->
21 | conn
22 | |> delete_session(@pending)
23 | |> UserAuth.redirect_user_after_login(user_params)
24 |
25 | {:valid_backup_code, remaining} ->
26 | plural = ngettext("backup code", "backup codes", remaining)
27 |
28 | conn
29 | |> delete_session(@pending)
30 | |> put_flash(
31 | :info,
32 | "You have #{remaining} #{plural} left. " <>
33 | "You can generate new ones under the Two-factor authentication section in the Settings page"
34 | )
35 | |> UserAuth.redirect_user_after_login(user_params)
36 |
37 | :invalid ->
38 | render(conn, "new.html", error_message: "Invalid two-factor authentication code")
39 | end
40 | end
41 |
42 | defp redirect_if_totp_is_not_pending(conn, _opts) do
43 | if get_session(conn, @pending) do
44 | conn
45 | else
46 | conn
47 | |> UserAuth.redirect_user_after_login()
48 | |> halt()
49 | end
50 | end
51 | end
52 |
--------------------------------------------------------------------------------
/lib/guilda_web/endpoint.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.Endpoint do
2 | use Phoenix.Endpoint, otp_app: :guilda
3 |
4 | # The session will be stored in the cookie and signed,
5 | # this means its contents can be read but not tampered with.
6 | # Set :encryption_salt if you would also like to encrypt it.
7 | @session_options [
8 | store: :cookie,
9 | key: "_guilda_key",
10 | signing_salt: "JIeS5L0B",
11 | same_site: "Strict"
12 | ]
13 |
14 | socket "/live", Phoenix.LiveView.Socket,
15 | websocket: [connect_info: [:x_headers, :user_agent, :peer_data, session: @session_options]]
16 |
17 | # Serve at "/" the static files from "priv/static" directory.
18 | #
19 | # You should set gzip to true if you are running phx.digest
20 | # when deploying your static files in production.
21 | plug Plug.Static,
22 | at: "/",
23 | from: :guilda,
24 | gzip: false,
25 | only: ~w(css js fonts images favicon.ico robots.txt)
26 |
27 | # Code reloading can be explicitly enabled under the
28 | # :code_reloader configuration of your endpoint.
29 | if code_reloading? do
30 | socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket
31 | plug Phoenix.LiveReloader
32 | plug Phoenix.CodeReloader
33 | plug Phoenix.Ecto.CheckRepoStatus, otp_app: :guilda
34 | end
35 |
36 | plug Phoenix.LiveDashboard.RequestLogger,
37 | param_key: "request_logger",
38 | cookie_key: "request_logger"
39 |
40 | plug Plug.RequestId
41 | plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint]
42 |
43 | plug Plug.Parsers,
44 | parsers: [:urlencoded, :multipart, :json],
45 | pass: ["*/*"],
46 | json_decoder: Phoenix.json_library()
47 |
48 | plug Plug.MethodOverride
49 | plug Plug.Head
50 | plug Plug.Session, @session_options
51 | plug GuildaWeb.Router
52 | end
53 |
--------------------------------------------------------------------------------
/lib/guilda_web/gettext.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.Gettext do
2 | @moduledoc """
3 | A module providing Internationalization with a gettext-based API.
4 |
5 | By using [Gettext](https://hexdocs.pm/gettext),
6 | your module gains a set of macros for translations, for example:
7 |
8 | import GuildaWeb.Gettext
9 |
10 | # Simple translation
11 | gettext("Here is the string to translate")
12 |
13 | # Plural translation
14 | ngettext("Here is the string to translate",
15 | "Here are the strings to translate",
16 | 3)
17 |
18 | # Domain-based translation
19 | dgettext("errors", "Here is the error message to translate")
20 |
21 | See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
22 | """
23 | use Gettext, otp_app: :guilda
24 | end
25 |
--------------------------------------------------------------------------------
/lib/guilda_web/helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.Helpers do
2 | @moduledoc """
3 | General helpers used through the app.
4 | """
5 | use Phoenix.Component
6 | import GuildaWeb.Gettext
7 |
8 | def table(assigns) do
9 | extra = assigns_to_attributes(assigns, [:class, :empty_state, :id, :row_id, :tbody_extra, :col, :rows])
10 |
11 | assigns =
12 | assigns
13 | |> assign_new(:class, fn -> nil end)
14 | |> assign_new(:empty_state, fn -> gettext("No records to show.") end)
15 | |> assign_new(:id, fn -> false end)
16 | |> assign_new(:row_id, fn -> false end)
17 | |> assign_new(:tbody_extra, fn -> [] end)
18 | |> assign(:col, for(col <- assigns.col, col[:if] != false, do: col))
19 | |> assign(:extra, extra)
20 |
21 | ~H"""
22 |
23 |
24 |
25 | <%= for col <- @col do %>
26 | <%= col.label %>
27 | <% end %>
28 |
29 |
30 |
31 | <%= if @rows == [] do %>
32 |
33 | <%= @empty_state %>
34 |
35 | <% end %>
36 | <%= for row <- @rows do %>
37 |
38 | <%= for col <- @col do %>
39 |
40 | <%= render_slot(col, row) %>
41 |
42 | <% end %>
43 |
44 | <% end %>
45 |
46 |
47 | """
48 | end
49 |
50 | defp column_extra_attributes(col) do
51 | assigns_to_attributes(col, [:if, :class, :label])
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/episode_live/index.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.PodcastEpisodeLive.Index do
2 | @moduledoc """
3 | LiveView Component to list podcast episodes.
4 | """
5 | use GuildaWeb, :live_view
6 |
7 | alias Guilda.Podcasts
8 | alias Guilda.Podcasts.Episode
9 |
10 | @impl true
11 | def mount(_params, _session, socket) do
12 | {:ok, assign(socket, podcast_episodes: list_podcast_episodes())}
13 | end
14 |
15 | @impl true
16 | def handle_params(params, _url, socket) do
17 | {:noreply, apply_action(socket, socket.assigns.live_action, params)}
18 | end
19 |
20 | defp apply_action(socket, :index, _params) do
21 | socket
22 | |> assign(:page_title, "Quem Programa?")
23 | |> assign(:episode, nil)
24 | end
25 |
26 | defp apply_action(socket, :new, _params) do
27 | case Bodyguard.permit(Podcasts, :create_episode, socket.assigns.current_user) do
28 | :ok ->
29 | socket
30 | |> assign(:page_title, gettext("New Episode"))
31 | |> assign(:episode, %Episode{})
32 |
33 | {:error, error} ->
34 | socket
35 | |> put_flash(:error, Err.message(error))
36 | |> push_redirect(to: Routes.podcast_episode_index_path(socket, :index))
37 | end
38 | end
39 |
40 | defp apply_action(socket, :edit, %{"id" => id}) do
41 | case Bodyguard.permit(Podcasts, :update_episode, socket.assigns.current_user) do
42 | :ok ->
43 | socket
44 | |> assign(:page_title, gettext("Edit Episode"))
45 | |> assign(:episode, Podcasts.get_episode!(id))
46 |
47 | {:error, error} ->
48 | socket
49 | |> put_flash(:error, Err.message(error))
50 | |> push_redirect(to: Routes.podcast_episode_index_path(socket, :index))
51 | end
52 | end
53 |
54 | defp list_podcast_episodes do
55 | Podcasts.list_podcast_episodes()
56 | end
57 | end
58 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/episode_live/index.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 | <.live_component
4 | :if={@live_action in [:new, :edit]}
5 | module={GuildaWeb.Podcasts.PodcastEpisodeLive.FormComponent}
6 | id={@episode.id || :new}
7 | title={@page_title}
8 | action={@live_action}
9 | current_user={@current_user}
10 | episode={@episode}
11 | return_to={Routes.podcast_episode_index_path(@socket, :index)}
12 | />
13 |
14 |
15 |
18 |
19 | <%= gettext("Contribute financially to the Guilda's podcast at") %>
20 |
25 | https://apoia.se/guildatech
26 |
33 |
39 |
40 |
41 |
42 |
43 | <.button
44 | :if={Bodyguard.permit?(Podcasts, :create_episode, @current_user)}
45 | class="mt-3"
46 | patch={Routes.podcast_episode_index_path(@socket, :new)}
47 | >
48 | <%= gettext("New Episode") %>
49 |
50 |
53 |
54 |
55 | <%= gettext("No episodes to show.") %>
56 |
57 |
64 | <.live_component
65 | :for={episode <- @podcast_episodes}
66 | module={GuildaWeb.PodcastEpisodeLive.EpisodeComponent}
67 | id={"episode-card-#{episode.id}"}
68 | episode={episode}
69 | current_user={@current_user}
70 | />
71 |
72 |
73 |
74 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/finance_live/form_component.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.FinanceLive.FormComponent do
2 | @moduledoc """
3 | LiveView Component to display a form for a transaction.
4 | """
5 | use GuildaWeb, :live_component
6 |
7 | alias Guilda.Finances
8 |
9 | @impl true
10 | def update(%{transaction: transaction} = assigns, socket) do
11 | changeset = Finances.change_transaction(transaction) |> set_transaction_type()
12 |
13 | {:ok,
14 | socket
15 | |> assign(assigns)
16 | |> assign(:changeset, changeset)}
17 | end
18 |
19 | @impl true
20 | def handle_event("validate", %{"transaction" => transaction_params}, socket) do
21 | changeset =
22 | socket.assigns.transaction
23 | |> Finances.change_transaction(toggle_amount_signal(transaction_params))
24 | |> Map.put(:action, :validate)
25 |
26 | {:noreply, assign(socket, :changeset, changeset)}
27 | end
28 |
29 | def handle_event("save", %{"transaction" => transaction_params}, socket) do
30 | save_transaction(socket, socket.assigns.action, transaction_params)
31 | end
32 |
33 | defp save_transaction(socket, :edit, transaction_params) do
34 | case Finances.update_transaction(
35 | socket.assigns.current_user,
36 | socket.assigns.transaction,
37 | toggle_amount_signal(transaction_params)
38 | ) do
39 | {:ok, _transaction} ->
40 | {:noreply,
41 | socket
42 | |> put_flash(:info, "Transaction updated successfully.")
43 | |> push_redirect(to: socket.assigns.return_to)}
44 |
45 | {:error, %Ecto.Changeset{} = changeset} ->
46 | {:noreply, assign(socket, :changeset, changeset)}
47 |
48 | {:error, error} ->
49 | {:noreply,
50 | socket
51 | |> put_flash(:error, Err.message(error))
52 | |> push_redirect(to: Routes.finance_index_path(socket, :index))}
53 | end
54 | end
55 |
56 | defp save_transaction(socket, :new, transaction_params) do
57 | case Finances.create_transaction(socket.assigns.current_user, toggle_amount_signal(transaction_params)) do
58 | {:ok, _transaction} ->
59 | {:noreply,
60 | socket
61 | |> put_flash(:info, "Transaction created successfully.")
62 | |> push_redirect(to: socket.assigns.return_to)}
63 |
64 | {:error, %Ecto.Changeset{} = changeset} ->
65 | {:noreply, assign(socket, changeset: changeset)}
66 |
67 | {:error, error} ->
68 | {:noreply,
69 | socket
70 | |> put_flash(:error, Err.message(error))
71 | |> push_redirect(to: Routes.finance_index_path(socket, :index))}
72 | end
73 | end
74 |
75 | defp set_transaction_type(changeset) do
76 | negative_amount = Decimal.lt?(Ecto.Changeset.get_field(changeset, :amount), 0)
77 |
78 | if negative_amount do
79 | Ecto.Changeset.put_change(changeset, :transaction_type, :outflow)
80 | else
81 | Ecto.Changeset.put_change(changeset, :transaction_type, :inflow)
82 | end
83 | end
84 |
85 | defp toggle_amount_signal(attrs) do
86 | type = Map.get(attrs, "transaction_type")
87 |
88 | Map.update(attrs, "amount", "", fn
89 | "" ->
90 | "0.00"
91 |
92 | "0" ->
93 | "0.00"
94 |
95 | "0.00" ->
96 | "0.00"
97 |
98 | value when type == "inflow" ->
99 | String.replace(value, "-", "")
100 |
101 | value ->
102 | value = String.replace(value, "-", "")
103 | "-#{value}"
104 | end)
105 | end
106 | end
107 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/finance_live/form_component.html.heex:
--------------------------------------------------------------------------------
1 |
2 | <.modal id="transaction-form-modal" patch={@return_to} show prevent_click_away>
3 | <:title><%= @title %>
4 | <.form :let={f} for={@changeset} id="transaction-form" phx-target={@myself} phx-change="validate" phx-submit="save">
5 |
6 | <.input type="text" field={{f, :payee}} label={gettext("Beneficiary")} />
7 | <.input
8 | type="text"
9 | field={{f, :amount}}
10 | label={gettext("Amount")}
11 | phx-hook="CurrencyMask"
12 | inputmode="numeric"
13 | prefix="$"
14 | />
15 | <.input type="radio" field={{f, :transaction_type}} label={gettext("Transaction type")}>
16 | <:entry label={gettext("Inflow")} value="inflow" />
17 | <:entry label={gettext("Outflow")} value="outflow" />
18 |
19 | <.input field={{f, :date}} type="datepicker" data-remove-min-date="true" label="Date" />
20 | <.input field={{f, :note}} type="textarea" label={gettext("Note")} />
21 |
22 |
23 |
24 | <:submit form="transaction-form"><%= gettext("Save") %>
25 | <:cancel><%= gettext("Cancel") %>
26 |
27 |
4 |
5 | <.button color="white" patch={Routes.finance_index_path(@socket, :new)}>
6 | <%= gettext("New Transaction") %>
7 |
8 |
9 |
10 |
11 |
12 |
13 | <.table id="transactions-table" rows={@transactions}>
14 | <:col :let={transaction} label={gettext("Date")}>
15 | <%= transaction.date %>
16 |
17 |
18 | <:col :let={transaction} label={gettext("Beneficiary")}>
19 | <%= transaction.payee %>
20 |
21 |
22 | <:col :let={transaction} label={gettext("Note")}>
23 | <%= transaction.note %>
24 |
25 |
26 | <:col :let={transaction} label={gettext("Amount")} align="right">
27 | <%= transaction.amount %>
28 |
29 |
30 | <:action :let={transaction} :if={Bodyguard.permit?(Finances, :update_transaction, @current_user)}>
31 | <.button size="xs" variant="outline" patch={Routes.finance_index_path(@socket, :edit, transaction)}>
32 | <%= gettext("Edit") %>
33 |
34 |
35 | <:action :let={transaction} :if={Bodyguard.permit?(Finances, :delete_transaction, @current_user)}>
36 | <.button
37 | size="xs"
38 | color="danger"
39 | variant="outline"
40 | id={"delete-transaction-#{transaction.id}"}
41 | phx-click={show_modal("delete-modal-#{transaction.id}")}
42 | >
43 | <%= gettext("Delete") %>
44 |
45 |
46 |
47 |
48 |
49 |
50 | <.modal
51 | :for={transaction <- @transactions}
52 | type="delete"
53 | id={"delete-modal-#{transaction.id}"}
54 | on_confirm={
55 | JS.push("delete", value: %{id: transaction.id})
56 | |> hide_modal("delete-modal-#{transaction.id}")
57 | |> hide("#transaction-#{transaction.id}")
58 | }
59 | >
60 | <:title><%= gettext("Delete") %>
61 | <%= gettext("Are you sure you want to remove the record from %{date} with amount %{value}?",
62 | date: transaction.date,
63 | value: transaction.amount
64 | ) %>
65 | <:cancel><%= gettext("Cancel") %>
66 | <:confirm><%= gettext("Delete") %>
67 |
68 |
69 |
70 | <.live_component
71 | :if={@live_action in [:new, :edit]}
72 | module={GuildaWeb.FinanceLive.FormComponent}
73 | id={@transaction.id || :new}
74 | title={@page_title}
75 | action={@live_action}
76 | current_user={@current_user}
77 | transaction={@transaction}
78 | return_to={Routes.finance_index_path(@socket, :index)}
79 | />
80 |
81 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/home_live.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.HomeLive do
2 | @moduledoc """
3 | LiveView to generate static pages.
4 | """
5 | use GuildaWeb, {:live_view, container: {:div, class: "flex flex-col flex-grow"}}
6 | alias Guilda.Podcasts
7 |
8 | @impl true
9 | def mount(_params, _session, socket) do
10 | socket =
11 | socket
12 | |> assign(:page_title, gettext("Home"))
13 | |> assign(:featured_episode, Podcasts.most_recent_episode())
14 |
15 | {:ok, socket}
16 | end
17 | end
18 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/home_live.html.heex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
10 |
11 | <%= gettext(
12 | "We are an inclusive community where all kinds of issues are addressed, including programming. "
13 | ) %>
14 |
15 |
16 |
17 |
26 |
27 |
28 |
29 |
30 |
31 | <%= gettext("Quem Programa?") %>
32 |
33 |
34 | <%= live_redirect to: Routes.podcast_episode_index_path(@socket, :index), class: "font-medium text-yellow-500 hover:text-yellow-500" do %>
35 | <%= gettext("Listen to the new episode of the GuildaTech podcast") %>
36 | →
37 | <% end %>
38 |
39 |
40 |
41 |
46 |
47 |
48 |
49 |
50 |
<%= gettext("Connect") %>
51 |
52 | <.link navigate="https://github.com/guildatech/" title="GitHub" class="text-yellow-300 hover:text-yellow-400">
53 |
56 |
57 | <.link navigate="https://t.me/guildatech" title="Telegram" class="text-yellow-300 hover:text-yellow-400">
58 |
61 |
62 | <.link navigate="https://twitter.com/guildatech" title="Twitter" class="text-yellow-300 hover:text-yellow-400">
63 |
66 |
67 |
69 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/members_live.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.MembersLive do
2 | @moduledoc """
3 | LiveView to display a map with all recorded user's locations.
4 | """
5 | use GuildaWeb, :live_view
6 |
7 | alias Guilda.Accounts
8 |
9 | @impl true
10 | def mount(_params, _session, socket) do
11 | if connected?(socket) do
12 | Phoenix.PubSub.subscribe(Guilda.PubSub, "member_location")
13 | end
14 |
15 | {:ok,
16 | assign(socket,
17 | page_title: gettext("Members list"),
18 | markers: Accounts.list_users_locations(),
19 | bot_name: GuildaWeb.AuthController.telegram_bot_username()
20 | ), temporary_assigns: [markers: []]}
21 | end
22 |
23 | @impl true
24 | def handle_info({Accounts, %Accounts.Events.LocationAdded{} = update}, socket) do
25 | {:noreply, update(socket, :markers, fn markers -> [%{lat: update.lat, lng: update.lng} | markers] end)}
26 | end
27 |
28 | def handle_info({Accounts, _}, socket), do: {:noreply, socket}
29 | end
30 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/members_live.html.heex:
--------------------------------------------------------------------------------
1 | <.main_content title={gettext("Members list")} flash={@flash}>
2 | <%= if @markers == [] do %>
3 |
4 |
5 |
<%= gettext("No location shared") %>
6 |
7 | <%= gettext("Submit your location to our bot @%{bot_name} and be the first to appear on our member map!",
8 | bot_name: @bot_name
9 | ) %>
10 |
11 |
14 |
15 |
17 |
18 | <% end %>
19 |
20 |
<%= gettext("How to share your location") %>
21 |
22 | <%= raw(
23 | gettext(
24 | "To register on the members map, 1) register your user account, 2) connect your Telegram account in the Settings page and 3) send your geographic location to our bot (%{link}). Sending location depends on the use of GPS, and only Telegram mobile clients (Android and iPhone) support sending coordinates.",
25 | link: safe_to_string(link("@#{@bot_name}", to: "https://t.me/#{@bot_name}"))
26 | )
27 | ) %>
28 |
29 |
30 | <%= raw(
31 | gettext(
32 | "It is important to send a private message directly to our bot %{link} with your location. Don't send your location to the group! ",
33 | link: safe_to_string(link("@#{@bot_name}", to: "https://t.me/#{@bot_name}"))
34 | )
35 | ) %>
36 |
37 |
<%= gettext("To ensure your privacy, all shared locations are saved with a 10km error margin.") %>
38 |
16 |
17 |
19 | <%= @online_users_count %> <%= gettext("online") %>
20 |
21 | <% else %>
22 |
23 |
24 |
26 | <%= gettext("Connecting") %>
27 |
28 | <% end %>
29 | """
30 | end
31 |
32 | @impl Phoenix.LiveView
33 | def mount(_params, _session, socket) do
34 | GuildaWeb.Presence.subscribe_to_online_users()
35 |
36 | if connected?(socket) do
37 | if user = socket.assigns[:current_user] do
38 | GuildaWeb.Presence.track_user(user.id)
39 | else
40 | if peer_data = get_connect_info(socket, :peer_data) do
41 | GuildaWeb.Presence.track_user(:inet.ntoa(peer_data.address))
42 | end
43 | end
44 | end
45 |
46 | {:ok, count_users(socket), layout: false}
47 | end
48 |
49 | @impl Phoenix.LiveView
50 | def handle_info(_, socket) do
51 | {:noreply, count_users(socket)}
52 | end
53 |
54 | defp count_users(socket) do
55 | users_count = GuildaWeb.Presence.list_users("online_users") |> Map.keys() |> Kernel.length()
56 | assign(socket, :online_users_count, users_count)
57 | end
58 | end
59 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/user_setting_live.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.UserSettingLive do
2 | @moduledoc """
3 | LiveView to update a user's settings.
4 | """
5 | use GuildaWeb, :live_view
6 |
7 | alias Guilda.Accounts
8 |
9 | on_mount GuildaWeb.MountHooks.RequireUser
10 |
11 | @impl Phoenix.LiveView
12 | def mount(_params, _session, socket) do
13 | if connected?(socket) do
14 | Accounts.subscribe(socket.assigns.current_user.id)
15 | end
16 |
17 | {:ok,
18 | assign(socket,
19 | password_changeset: Accounts.change_user_password(socket.assigns.current_user),
20 | is_legacy_account?: Accounts.is_legacy_account?(socket.assigns.current_user),
21 | password_trigger_action: false,
22 | current_password: nil,
23 | bot_name: GuildaWeb.AuthController.telegram_bot_username()
24 | )}
25 | end
26 |
27 | @impl Phoenix.LiveView
28 | def handle_params(_params, _url, socket) do
29 | {:noreply, assign(socket, :page_title, gettext("Settings"))}
30 | end
31 |
32 | @impl Phoenix.LiveView
33 | def handle_event(
34 | "validate-password",
35 | %{"current_password" => current_password, "user" => user_params},
36 | socket
37 | ) do
38 | password_changeset = Accounts.change_user_password(socket.assigns.current_user, current_password, user_params)
39 |
40 | socket =
41 | socket
42 | |> assign(:current_password, current_password)
43 | |> assign(:password_changeset, password_changeset)
44 |
45 | {:noreply, socket}
46 | end
47 |
48 | def handle_event(
49 | "update-password",
50 | %{"current_password" => current_password, "user" => user_params},
51 | socket
52 | ) do
53 | socket = assign(socket, :current_password, current_password)
54 |
55 | socket.assigns.current_user
56 | |> Accounts.apply_user_password(current_password, user_params)
57 | |> case do
58 | {:ok, _} ->
59 | {:noreply, assign(socket, :password_trigger_action, true)}
60 |
61 | {:error, password_changeset} ->
62 | {:noreply, assign(socket, :password_changeset, password_changeset)}
63 | end
64 | end
65 |
66 | def handle_event("remove-location", _params, socket) do
67 | user = socket.assigns.current_user
68 |
69 | case Accounts.remove_location(socket.assigns.audit_context, user) do
70 | {:ok, user} ->
71 | {:noreply,
72 | socket
73 | |> put_flash(:info, gettext("Your location was removed successfully."))
74 | |> assign(:current_user, user)}
75 |
76 | {:error, _changeset} ->
77 | {:noreply, put_flash(socket, :error, gettext("Failed to remove your location."))}
78 | end
79 | end
80 |
81 | def handle_event("disconnect-telegram", _params, socket) do
82 | user = socket.assigns.current_user
83 |
84 | case Accounts.disconnect_provider(socket.assigns.audit_context, user, :telegram) do
85 | {:ok, user} ->
86 | {:noreply,
87 | socket
88 | |> put_flash(:info, gettext("Your Telegram account was successfully disconnected."))
89 | |> assign(:current_user, user)}
90 |
91 | {:error, _changeset} ->
92 | {:noreply, put_flash(socket, :error, gettext("Failed to remove your location."))}
93 | end
94 | end
95 |
96 | def handle_event("resend-confirmation", _params, socket) do
97 | Accounts.deliver_user_confirmation_instructions(
98 | socket.assigns.current_user,
99 | &Routes.user_confirmation_url(socket, :edit, &1)
100 | )
101 |
102 | {:noreply,
103 | put_flash(socket, :info, gettext("You will receive an email with instructions to confirm your account shortly."))}
104 | end
105 |
106 | @impl Phoenix.LiveView
107 | def handle_info({Accounts, %Accounts.Events.LocationChanged{} = update}, socket) do
108 | {:noreply, assign(socket, current_user: update.user)}
109 | end
110 |
111 | def handle_info({Accounts, _}, socket), do: {:noreply, socket}
112 | end
113 |
--------------------------------------------------------------------------------
/lib/guilda_web/live/user_settings_live/add_email_password_component.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.UserSettingsLive.AddEmailPasswordComponent do
2 | @moduledoc """
3 | Component used to add email/password to legacy accounts.
4 | """
5 | use GuildaWeb, :live_component
6 |
7 | alias Guilda.Accounts
8 |
9 | @impl true
10 | def update(assigns, socket) do
11 | {:ok,
12 | socket
13 | |> assign(:audit_context, assigns.audit_context)
14 | |> assign(:current_user, assigns.current_user)
15 | |> assign(:changeset, Accounts.change_user_registration(assigns.current_user))}
16 | end
17 |
18 | @impl true
19 | def render(assigns) do
20 | ~H"""
21 |
22 | <.content_section
23 | title={gettext("Set Email and Password")}
24 | subtitle={gettext("Upgrade from a Telegram-only login to access enhanced features.")}
25 | }
26 | >
27 |
28 |
29 |
45 |
46 |
<%= gettext("Attention needed") %>
47 |
48 |
<%= gettext("You're signed in using an old account that does not have an email or password set.") %>
49 |
50 | <%= gettext("Please add an email to your account to access newer accounts feature like 2FA and Webauthn.") %>
51 |
52 |
53 |
54 |
55 |
56 | <.card class="mt-5">
57 | <.form :let={f} id="add-email-form" for={@changeset} phx-submit="add-email" phx-target={@myself}>
58 |
59 |
60 |
61 | <.input field={{f, :email}} type="text" label={gettext("Email")} />
62 | <.input field={{f, :password}} type="password" label={gettext("Password")} />
63 |
64 |
65 |
66 |
67 | <:footer>
68 | <.button type="submit" form="add-email-form"><%= gettext("Save") %>
69 |
70 |
71 |
72 |
")
18 | "..."
19 |
20 | iex> compile!("")
21 | "..."
22 |
23 | iex> compile!(%Swoosh.Email{html_body: ""})
24 | %Swoosh.Email{html_body: "..."}
25 |
26 | iex> compile!(%Swoosh.Email{html_body: ""})
27 | %Swoosh.Email{html_body: "..."}
28 |
29 | """
30 | @type compiled_template :: String.t() | Swoosh.Email.t()
31 | @spec compile!(String.t() | Swoosh.Email.t()) :: compiled_template()
32 | def compile!(email_or_template)
33 |
34 | def compile!(%Swoosh.Email{html_body: body} = email) do
35 | Map.put(email, :html_body, compile!(body))
36 | end
37 |
38 | def compile!(email_or_template) when is_binary(email_or_template) do
39 | if email_or_template =~ "", do: do_compile_mjml!(email_or_template), else: email_or_template
40 | end
41 |
42 | def compile!(email_or_template) do
43 | raise ArgumentError,
44 | "Expected either a %Swoosh.Email{} or valid HTML or MJML template, got: #{inspect(email_or_template)}"
45 | end
46 |
47 | defp do_compile_mjml!(template) do
48 | case Mjml.to_html(template) do
49 | {:ok, html} -> html
50 | {:error, error} -> raise "Mjml compilation returned #{inspect(error)}, mail has not been compiled."
51 | end
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/lib/guilda_web/mount_hooks/init_assigns.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.MountHooks.InitAssigns do
2 | @moduledoc """
3 | Ensures common `assigns` are applied to all LiveViews attaching this hook.
4 | """
5 | import Phoenix.Component, only: [assign: 2, assign_new: 3]
6 | alias Guilda.Accounts
7 | alias GuildaWeb.RequestContext
8 |
9 | def on_mount(_any, _params, session, socket) do
10 | socket =
11 | socket
12 | |> assign_menu()
13 | |> assign_user(session)
14 | |> RequestContext.put_audit_context()
15 |
16 | {:cont, socket}
17 | end
18 |
19 | defp assign_menu(socket) do
20 | assign(socket, menu: %{action: socket.assigns.live_action, module: socket.view})
21 | end
22 |
23 | defp assign_user(socket, %{"user_token" => user_token}) do
24 | socket
25 | |> assign_new(:user_token, fn -> user_token end)
26 | |> assign_new(:current_user, fn -> Accounts.get_user_by_session_token(user_token) end)
27 | end
28 |
29 | defp assign_user(socket, _) do
30 | assign(socket, current_user: nil)
31 | end
32 | end
33 |
--------------------------------------------------------------------------------
/lib/guilda_web/mount_hooks/require_user.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.MountHooks.RequireUser do
2 | @moduledoc """
3 | Ensures common `assigns` are applied to all LiveViews attaching this hook.
4 | """
5 | import Phoenix.LiveView
6 | import GuildaWeb.Gettext
7 |
8 | alias GuildaWeb.Router.Helpers, as: Routes
9 |
10 | def on_mount(_any, _params, _session, socket) do
11 | if socket.assigns[:current_user] do
12 | {:cont, socket}
13 | else
14 | socket =
15 | socket
16 | |> put_flash(:error, gettext("You must be signed in to access this page."))
17 | |> redirect(to: Routes.user_session_path(socket, :new))
18 |
19 | {:halt, socket}
20 | end
21 | end
22 | end
23 |
--------------------------------------------------------------------------------
/lib/guilda_web/mount_hooks/track_presence.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.MountHooks.TrackPresence do
2 | @moduledoc """
3 | Ensures common `assigns` are applied to all LiveViews attaching this hook.
4 | """
5 |
6 | def on_mount(_any, _params, _session, socket) do
7 | if user = socket.assigns[:current_user] do
8 | GuildaWeb.Presence.track_user(user.id)
9 | end
10 |
11 | {:cont, socket}
12 | end
13 | end
14 |
--------------------------------------------------------------------------------
/lib/guilda_web/request_context.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.RequestContext do
2 | @moduledoc false
3 | alias Guilda.AuditLog
4 | alias Guilda.Extensions.Ecto.IPAddress
5 |
6 | def put_audit_context(conn_or_socket, opts \\ [])
7 |
8 | def put_audit_context(%Plug.Conn{} = conn, _) do
9 | user_agent =
10 | case List.keyfind(conn.req_headers, "user-agent", 0) do
11 | {_, value} -> value
12 | _ -> nil
13 | end
14 |
15 | Plug.Conn.assign(conn, :audit_context, %AuditLog{
16 | user_agent: user_agent,
17 | ip_address: get_ip(conn.req_headers),
18 | user: conn.assigns[:current_user]
19 | })
20 | end
21 |
22 | def put_audit_context(%Phoenix.LiveView.Socket{} = socket, _) do
23 | audit_context = %AuditLog{
24 | user: socket.assigns[:current_user]
25 | }
26 |
27 | Phoenix.Component.assign_new(socket, :audit_context, fn -> audit_context end)
28 | end
29 |
30 | defp get_ip(headers) do
31 | with {_, ip} <- List.keyfind(headers, "x-forwarded-for", 0),
32 | [ip | _] = String.split(ip, ","),
33 | {:ok, address} <- IPAddress.cast(ip) do
34 | address
35 | else
36 | _ ->
37 | nil
38 | end
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/lib/guilda_web/simple_s3_upload.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.SimpleS3Upload do
2 | @moduledoc """
3 | Dependency-free S3 Form Upload using HTTP POST sigv4
4 | https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-post-example.html
5 | """
6 |
7 | @doc """
8 | Signs a form upload.
9 | The configuration is a map which must contain the following keys:
10 | * `:region` - The AWS region, such as "us-east-1"
11 | * `:access_key_id` - The AWS access key id
12 | * `:secret_access_key` - The AWS secret access key
13 | Returns a map of form fields to be used on the client via the JavaScript `FormData` API.
14 |
15 | ## Options
16 | * `:key` - The required key of the object to be uploaded.
17 | * `:max_file_size` - The required maximum allowed file size in bytes.
18 | * `:content_type` - The required MIME type of the file to be uploaded.
19 | * `:expires_in` - The required expiration time in milliseconds from now
20 | before the signed upload expires.
21 | ## Examples
22 | config = %{
23 | region: "us-east-1",
24 | access_key_id: System.fetch_env!("AWS_ACCESS_KEY_ID"),
25 | secret_access_key: System.fetch_env!("AWS_SECRET_ACCESS_KEY")
26 | }
27 | {:ok, fields} =
28 | SimpleS3Upload.sign_form_upload(config, "my-bucket",
29 | key: "public/my-file-name",
30 | content_type: "image/png",
31 | max_file_size: 10_000,
32 | expires_in: :timer.hours(1)
33 | )
34 | """
35 | def sign_form_upload(config, bucket, opts) do
36 | key = Keyword.fetch!(opts, :key)
37 | max_file_size = Keyword.fetch!(opts, :max_file_size)
38 | content_type = Keyword.fetch!(opts, :content_type)
39 | expires_in = Keyword.fetch!(opts, :expires_in)
40 |
41 | expires_at = DateTime.add(DateTime.utc_now(), expires_in, :millisecond)
42 | amz_date = amz_date(expires_at)
43 | credential = credential(config, expires_at)
44 |
45 | encoded_policy =
46 | Base.encode64("""
47 | {
48 | "expiration": "#{DateTime.to_iso8601(expires_at)}",
49 | "conditions": [
50 | {"bucket": "#{bucket}"},
51 | ["eq", "$key", "#{key}"],
52 | {"acl": "public-read"},
53 | ["eq", "$Content-Type", "#{content_type}"],
54 | ["content-length-range", 0, #{max_file_size}],
55 | {"x-amz-server-side-encryption": "AES256"},
56 | {"x-amz-credential": "#{credential}"},
57 | {"x-amz-algorithm": "AWS4-HMAC-SHA256"},
58 | {"x-amz-date": "#{amz_date}"}
59 | ]
60 | }
61 | """)
62 |
63 | fields = %{
64 | "key" => key,
65 | "acl" => "public-read",
66 | "content-type" => content_type,
67 | "x-amz-server-side-encryption" => "AES256",
68 | "x-amz-credential" => credential,
69 | "x-amz-algorithm" => "AWS4-HMAC-SHA256",
70 | "x-amz-date" => amz_date,
71 | "policy" => encoded_policy,
72 | "x-amz-signature" => signature(config, expires_at, encoded_policy)
73 | }
74 |
75 | {:ok, fields}
76 | end
77 |
78 | defp amz_date(time) do
79 | time
80 | |> NaiveDateTime.to_iso8601()
81 | |> String.split(".")
82 | |> List.first()
83 | |> String.replace("-", "")
84 | |> String.replace(":", "")
85 | |> Kernel.<>("Z")
86 | end
87 |
88 | defp credential(%{} = config, %DateTime{} = expires_at) do
89 | "#{config.access_key_id}/#{short_date(expires_at)}/#{config.region}/s3/aws4_request"
90 | end
91 |
92 | defp signature(config, %DateTime{} = expires_at, encoded_policy) do
93 | config
94 | |> signing_key(expires_at, "s3")
95 | |> sha256(encoded_policy)
96 | |> Base.encode16(case: :lower)
97 | end
98 |
99 | defp signing_key(%{} = config, %DateTime{} = expires_at, service) when service in ["s3"] do
100 | amz_date = short_date(expires_at)
101 | %{secret_access_key: secret, region: region} = config
102 |
103 | ("AWS4" <> secret)
104 | |> sha256(amz_date)
105 | |> sha256(region)
106 | |> sha256(service)
107 | |> sha256("aws4_request")
108 | end
109 |
110 | defp short_date(%DateTime{} = expires_at) do
111 | expires_at
112 | |> amz_date()
113 | |> String.slice(0..7)
114 | end
115 |
116 | defp sha256(secret, msg), do: :crypto.mac(:hmac, :sha256, secret, msg)
117 | end
118 |
--------------------------------------------------------------------------------
/lib/guilda_web/telemetry.ex:
--------------------------------------------------------------------------------
1 | defmodule GuildaWeb.Telemetry do
2 | @moduledoc false
3 |
4 | use Supervisor
5 | import Telemetry.Metrics
6 |
7 | def start_link(arg) do
8 | Supervisor.start_link(__MODULE__, arg, name: __MODULE__)
9 | end
10 |
11 | @impl true
12 | def init(_arg) do
13 | children = [
14 | # Telemetry poller will execute the given period measurements
15 | # every 10_000ms. Learn more here: https://hexdocs.pm/telemetry_metrics
16 | {:telemetry_poller, measurements: periodic_measurements(), period: 10_000}
17 | # Add reporters as children of your supervision tree.
18 | # {Telemetry.Metrics.ConsoleReporter, metrics: metrics()}
19 | ]
20 |
21 | Supervisor.init(children, strategy: :one_for_one)
22 | end
23 |
24 | def metrics do
25 | [
26 | # Phoenix Metrics
27 | summary("phoenix.endpoint.stop.duration",
28 | unit: {:native, :millisecond}
29 | ),
30 | summary("phoenix.router_dispatch.stop.duration",
31 | tags: [:route],
32 | unit: {:native, :millisecond}
33 | ),
34 |
35 | # Database Metrics
36 | summary("guilda.repo.query.total_time", unit: {:native, :millisecond}),
37 | summary("guilda.repo.query.decode_time", unit: {:native, :millisecond}),
38 | summary("guilda.repo.query.query_time", unit: {:native, :millisecond}),
39 | summary("guilda.repo.query.queue_time", unit: {:native, :millisecond}),
40 | summary("guilda.repo.query.idle_time", unit: {:native, :millisecond}),
41 |
42 | # VM Metrics
43 | summary("vm.memory.total", unit: {:byte, :kilobyte}),
44 | summary("vm.total_run_queue_lengths.total"),
45 | summary("vm.total_run_queue_lengths.cpu"),
46 | summary("vm.total_run_queue_lengths.io")
47 | ]
48 | end
49 |
50 | defp periodic_measurements do
51 | [
52 | # A module, function and arguments to be invoked periodically.
53 | # This function must call :telemetry.execute/3 and a metric must be added above.
54 | # {GuildaWeb, :count_users, []}
55 | ]
56 | end
57 | end
58 |
--------------------------------------------------------------------------------
/lib/guilda_web/templates/feed/index.xml.eex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Quem Programa?
5 | pt-br
7 | © 2021 GuildaTech
8 | O podcast que fala da vida na TI sem ser complicado, mostrando a trajetória das pessoas por trás da tecnologia.
9 | O podcast da GuildaTech
10 | GuildaTech
11 |
12 | GuildaTech
13 | podcast@guildatech.com
14 |
15 | false
16 | " />
17 | -
23 |
<%= episode.id %>
24 | <%= episode.title %>
25 | <%= Timex.format!(episode.aired_date, "%a, %d %b %Y %T %z", :strftime) %>
26 |
29 | ]]>
30 |
31 | <%= episode.hosts %>
32 | <%= GuildaWeb.ViewHelpers.format_seconds(episode.length) %>
33 | false
34 |
35 | <% end %>
36 |
37 |
38 |
--------------------------------------------------------------------------------
/lib/guilda_web/templates/layout/app.html.heex:
--------------------------------------------------------------------------------
1 | <%= live_render(@conn, GuildaWeb.MenuLive, id: "menu", session: %{"menu" => @menu, "current_user" => @current_user}) %>
2 |
3 | <%= if msg = get_flash(@conn, :info) do %>
4 |
5 |
6 | <%= msg %>
7 |
8 |
12 |
13 | <%= msg %>
14 |
15 |
2 |
3 | <%= @email.subject %>
4 |
5 |
6 |
7 |
8 |
19 |
20 |
21 |
22 |
23 |
24 |
35 | <%= @email.subject %>
36 |
37 |
38 |
39 |
40 |
41 | <%= @inner_content %>
42 |
43 |
44 |
45 |
46 |
--------------------------------------------------------------------------------
/lib/guilda_web/templates/layout/email.text.eex:
--------------------------------------------------------------------------------
1 | <%= @email.subject %>
2 |
3 | =========================
4 |
5 | <%= @inner_content %>
6 |
7 | =========================
8 |
9 | Thanks,
10 | The GuildaTech Team
--------------------------------------------------------------------------------
/lib/guilda_web/templates/layout/live.html.heex:
--------------------------------------------------------------------------------
1 | <%= live_render(@socket, GuildaWeb.MenuLive, id: "menu", session: %{"menu" => @menu, "current_user" => @current_user}) %>
2 |
3 | <%= if msg = live_flash(@flash, :info) do %>
4 |
5 |
6 | <%= msg %>
7 |
8 |
12 |
13 | <%= msg %>
14 |
15 |
3 |
4 | <.form :let={_f} for={:user} action={Routes.user_confirmation_path(@conn, :update, @token)}>
5 |
6 |
7 | <.button type="submit" class="w-full"><%= gettext("Confirm my account") %>
8 |
9 |
10 |
11 |
12 | <.link
13 | navigate={Routes.user_registration_path(@conn, :new)}
14 | class="font-medium text-primary-600 hover:text-primary-500"
15 | >
16 | <%= gettext("Register") %>
17 |
18 | |
19 | <.link
20 | navigate={Routes.user_session_path(@conn, :new)}
21 | class="font-medium text-primary-600 hover:text-primary-500"
22 | >
23 | <%= gettext("Sign in") %>
24 |
25 |
26 |
27 |
28 |
29 |
30 |
3 |
4 | <.form :let={f} for={:user} action={Routes.user_confirmation_path(@conn, :create)}>
5 |
6 |
7 | <%= label(f, :email, class: "block text-sm font-medium text-gray-700") %>
8 |
9 | <%= email_input(f, :email,
10 | required: true,
11 | class:
12 | "block w-full px-3 py-2 placeholder-gray-400 border border-gray-300 rounded-md shadow-sm appearance-none focus:outline-none focus:ring-primary-500 focus:border-primary-500 sm:text-sm"
13 | ) %>
14 |
15 |
16 |
17 |
18 |
19 | <.link
20 | navigate={Routes.user_registration_path(@conn, :new)}
21 | class="font-medium text-primary-600 hover:text-primary-500"
22 | >
23 | <%= gettext("Register") %>
24 |
25 | |
26 | <.link
27 | navigate={Routes.user_session_path(@conn, :new)}
28 | class="font-medium text-primary-600 hover:text-primary-500"
29 | >
30 | <%= gettext("Sign in") %>
31 |
32 |
33 |
34 |
35 |
36 | <.button type="submit" class="w-full"><%= gettext("Resend confirmation instructions") %>
37 |
38 |
39 |
40 |
41 |
9 | Hi <%= @user.email %>
10 |
11 |
19 | You can confirm your account by visiting the URL below:
20 |
21 |
31 | Confirm account
32 |
33 |
41 | If you didn't create an account with us, please ignore this.
42 |
43 |
51 | Thanks,
53 |
--------------------------------------------------------------------------------
/lib/guilda_web/templates/user_notifier/confirmation_instructions.text.eex:
--------------------------------------------------------------------------------
1 | Hi <%= @user.email %>,
2 |
3 | You can confirm your account by visiting the URL below:
4 |
5 | <%= @url %>
6 |
7 | If you didn't create an account with us, please ignore this.
--------------------------------------------------------------------------------
/lib/guilda_web/templates/user_notifier/reset_password_instructions.html.heex:
--------------------------------------------------------------------------------
1 |
9 | Hi <%= @user.email %>
10 |
11 |
19 | You can reset your password by visiting the URL below:
20 |
21 |
31 | Reset password
32 |
33 |
41 | If you didn't request this change, please ignore this.
42 |
43 |
51 | Thanks,
53 |
--------------------------------------------------------------------------------
/lib/guilda_web/templates/user_notifier/reset_password_instructions.text.eex:
--------------------------------------------------------------------------------
1 | Hi <%= @user.email %>,
2 |
3 | You can reset your password by visiting the URL below:
4 |
5 | <%= @url %>
6 |
7 | If you didn't request this change, please ignore this.
--------------------------------------------------------------------------------
/lib/guilda_web/templates/user_notifier/update_email_instructions.html.heex:
--------------------------------------------------------------------------------
1 |
9 | Hi <%= @user.email %>
10 |
11 |
19 | You can change your email by visiting the URL below:
20 |
21 |
31 | Reset password
32 |
33 |
41 | If you didn't request this change, please ignore this.
42 |
43 |
51 | Thanks,
53 |
--------------------------------------------------------------------------------
/lib/guilda_web/templates/user_notifier/update_email_instructions.text.eex:
--------------------------------------------------------------------------------
1 | Hi <%= @user.email %>,
2 |
3 | You can change your email by visiting the URL below:
4 |
5 | <%= @url %>
6 |
7 | If you didn't request this change, please ignore this.
--------------------------------------------------------------------------------
/lib/guilda_web/templates/user_registration/new.html.heex:
--------------------------------------------------------------------------------
1 | <.guest_content title={gettext("Register")} flash={get_flash(@conn)}>
2 |
3 |
4 | <.form :let={f} for={@changeset} action={Routes.user_registration_path(@conn, :create)}>
5 |
6 | <.error
7 | :if={@changeset.action}
8 | message={gettext("Oops, something went wrong! Please check the errors below.")}
9 | />
10 |
11 |
12 | <.input field={{f, :email}} label={gettext("Email")} />
13 |
14 |
15 |
16 | <.input type="password" field={{f, :password}} label={gettext("Password")} />
17 |
18 |
19 |
20 |
21 | <.link
22 | navigate={Routes.user_session_path(@conn, :new)}
23 | class="font-medium text-primary-600 hover:text-primary-500"
24 | >
25 | <%= gettext("Sign in") %>
26 |
27 | |
28 | <.link
29 | navigate={Routes.user_reset_password_path(@conn, :new)}
30 | class="font-medium text-primary-600 hover:text-primary-500"
31 | >
32 | <%= gettext("Forgot your password?") %>
33 |
34 |
35 |
36 |
37 |
38 | <.button type="submit" class="w-full"><%= gettext("Register") %>
39 |
40 |
41 |
42 |
43 |
3 |
4 | <.form :let={f} for={@changeset} action={Routes.user_reset_password_path(@conn, :update, @token)}>
5 |
6 | <%= if @changeset.action do %>
7 |
8 |
<%= gettext("Oops, something went wrong! Please check the errors below.") %>
9 |
10 | <% end %>
11 |
12 | <.input type="password" field={{f, :password}} label={gettext("New password")} />
13 |
14 |
15 |
16 | <.input type="password" field={{f, :password_confirmation}} label={gettext("Confirm new password")} />
17 |
18 |
19 |
20 |
21 | <.link
22 | navigate={Routes.user_registration_path(@conn, :new)}
23 | class="font-medium text-primary-600 hover:text-primary-500"
24 | >
25 | <%= gettext("Register") %>
26 |
27 | |
28 | <.link
29 | navigate={Routes.user_session_path(@conn, :new)}
30 | class="font-medium text-primary-600 hover:text-primary-500"
31 | >
32 | <%= gettext("Sign in") %>
33 |
34 |
35 |
36 |
37 |
38 | <.button type="submit" class="w-full"><%= gettext("Reset password") %>
39 |
40 |
41 |
42 |
43 |
3 |
4 | <.form :let={f} for={:user} action={Routes.user_reset_password_path(@conn, :create)}>
5 |
6 |
7 | <.input field={{f, :email}} label={gettext("Email")} />
8 |
9 |
10 |
11 |
12 | <.link
13 | navigate={Routes.user_registration_path(@conn, :new)}
14 | class="font-medium text-primary-600 hover:text-primary-500"
15 | >
16 | <%= gettext("Register") %>
17 |
18 | |
19 | <.link
20 | navigate={Routes.user_session_path(@conn, :new)}
21 | class="font-medium text-primary-600 hover:text-primary-500"
22 | >
23 | <%= gettext("Sign in") %>
24 |
25 |
26 |
27 |
28 |
29 | <.button type="submit" class="w-full"><%= gettext("Send instructions to reset password") %>
30 |
31 |
32 |
33 |
34 |
3 |
4 | <.form :let={f} for={@conn} action={Routes.user_session_path(@conn, :create)} as={:user}>
5 |
6 | <%= if @error_message do %>
7 |
8 |
<%= @error_message %>
9 |
10 | <% end %>
11 |
12 |
13 | <.input field={{f, :email}} label={gettext("Email")} />
14 |
15 |
16 |
17 | <.input type="password" field={{f, :password}} label={gettext("Password")} />
18 |
19 |
20 |
21 |
22 | <.link
23 | navigate={Routes.user_reset_password_path(@conn, :new)}
24 | class="font-medium text-primary-600 hover:text-primary-500"
25 | >
26 | <%= gettext("Forgot your password?") %>
27 |
28 | |
29 | <.link
30 | navigate={Routes.user_registration_path(@conn, :new)}
31 | class="font-medium text-primary-600 hover:text-primary-500"
32 | >
33 | <%= gettext("Register") %>
34 |
35 |
36 |
37 |
38 |
39 | <.button type="submit" class="w-full"><%= gettext("Sign in") %>
40 |
41 |
42 |
43 |
44 |
45 |
48 |
49 | <%= gettext("Or continue with") %>
50 |
51 |
52 |
53 |
68 |
69 |
70 |
3 |
4 | <.form :let={f} for={@conn} as={:user} action={Routes.user_totp_path(@conn, :create)}>
5 |
6 | <%= if @error_message do %>
7 |
8 |
<%= @error_message %>
9 |
10 | <% end %>
11 |
12 |
13 | <%= gettext(
14 | "Enter the six-digit code from your device or any of your eight-character backup codes to finish logging in."
15 | ) %>
16 |
17 |
18 |
19 | <.input field={{f, :code}} label={gettext("Code")} />
20 |
21 |
22 |
23 | <.button type="submit" class="w-full"><%= gettext("Verify code and sign in") %>
24 |
25 | or
26 | <.link
27 | navigate={Routes.user_session_path(@conn, :delete)}
28 | method="delete"
29 | class="font-medium text-primary-800"
30 | >
31 | <%= gettext("click here to sign out") %>
32 |
33 |
34 |
35 |
36 |
37 |
38 |