After "mix phx.gen.auth Admins Admin admins" with added working register and login path.

lib/beet_round_server_web/admin_auth.ex

@@ -0,0 +1,219 @@
+defmodule BeetRoundServerWeb.AdminAuth do
+  use BeetRoundServerWeb, :verified_routes
+
+  import Plug.Conn
+  import Phoenix.Controller
+
+  alias BeetRoundServer.Admins
+  alias BeetRoundServer.Admins.Scope
+
+  # Make the remember me cookie valid for 14 days. This should match
+  # the session validity setting in AdminToken.
+  @max_cookie_age_in_days 14
+  @remember_me_cookie "_beet_round_server_web_admin_remember_me"
+  @remember_me_options [
+    sign: true,
+    max_age: @max_cookie_age_in_days * 24 * 60 * 60,
+    same_site: "Lax"
+  ]
+
+  # How old the session token should be before a new one is issued. When a request is made
+  # with a session token older than this value, then a new session token will be created
+  # and the session and remember-me cookies (if set) will be updated with the new token.
+  # Lowering this value will result in more tokens being created by active users. Increasing
+  # it will result in less time before a session token expires for a user to get issued a new
+  # token. This can be set to a value greater than `@max_cookie_age_in_days` to disable
+  # the reissuing of tokens completely.
+  @session_reissue_age_in_days 7
+
+  @doc """
+  Logs the admin in.
+
+  Redirects to the session's `:admin_return_to` path
+  or falls back to the `signed_in_path/1`.
+  """
+  def log_in_admin(conn, admin, params \\ %{}) do
+    admin_return_to = get_session(conn, :admin_return_to)
+
+    conn
+    |> create_or_extend_session(admin, params)
+    |> redirect(to: admin_return_to || signed_in_path(conn))
+  end
+
+  @doc """
+  Logs the admin out.
+
+  It clears all session data for safety. See renew_session.
+  """
+  def log_out_admin(conn) do
+    admin_token = get_session(conn, :admin_token)
+    admin_token && Admins.delete_admin_session_token(admin_token)
+
+    if live_socket_id = get_session(conn, :live_socket_id) do
+      BeetRoundServerWeb.Endpoint.broadcast(live_socket_id, "disconnect", %{})
+    end
+
+    conn
+    |> renew_session(nil)
+    |> delete_resp_cookie(@remember_me_cookie)
+    |> redirect(to: ~p"/")
+  end
+
+  @doc """
+  Authenticates the admin by looking into the session and remember me token.
+
+  Will reissue the session token if it is older than the configured age.
+  """
+  def fetch_current_scope_for_admin(conn, _opts) do
+    with {token, conn} <- ensure_admin_token(conn),
+         {admin, token_inserted_at} <- Admins.get_admin_by_session_token(token) do
+      conn
+      |> assign(:current_scope, Scope.for_admin(admin))
+      |> maybe_reissue_admin_session_token(admin, token_inserted_at)
+    else
+      nil -> assign(conn, :current_scope, Scope.for_admin(nil))
+    end
+  end
+
+  defp ensure_admin_token(conn) do
+    if token = get_session(conn, :admin_token) do
+      {token, conn}
+    else
+      conn = fetch_cookies(conn, signed: [@remember_me_cookie])
+
+      if token = conn.cookies[@remember_me_cookie] do
+        {token, conn |> put_token_in_session(token) |> put_session(:admin_remember_me, true)}
+      else
+        nil
+      end
+    end
+  end
+
+  # Reissue the session token if it is older than the configured reissue age.
+  defp maybe_reissue_admin_session_token(conn, admin, token_inserted_at) do
+    token_age = DateTime.diff(DateTime.utc_now(:second), token_inserted_at, :day)
+
+    if token_age >= @session_reissue_age_in_days do
+      create_or_extend_session(conn, admin, %{})
+    else
+      conn
+    end
+  end
+
+  # This function is the one responsible for creating session tokens
+  # and storing them safely in the session and cookies. It may be called
+  # either when logging in, during sudo mode, or to renew a session which
+  # will soon expire.
+  #
+  # When the session is created, rather than extended, the renew_session
+  # function will clear the session to avoid fixation attacks. See the
+  # renew_session function to customize this behaviour.
+  defp create_or_extend_session(conn, admin, params) do
+    token = Admins.generate_admin_session_token(admin)
+    remember_me = get_session(conn, :admin_remember_me)
+
+    conn
+    |> renew_session(admin)
+    |> put_token_in_session(token)
+    |> maybe_write_remember_me_cookie(token, params, remember_me)
+  end
+
+  # Do not renew session if the admin is already logged in
+  # to prevent CSRF errors or data being lost in tabs that are still open
+  defp renew_session(conn, admin) when conn.assigns.current_scope.admin.id == admin.id do
+    conn
+  end
+
+  # This function renews the session ID and erases the whole
+  # session to avoid fixation attacks. If there is any data
+  # in the session you may want to preserve after log in/log out,
+  # you must explicitly fetch the session data before clearing
+  # and then immediately set it after clearing, for example:
+  #
+  #     defp renew_session(conn, _admin) do
+  #       delete_csrf_token()
+  #       preferred_locale = get_session(conn, :preferred_locale)
+  #
+  #       conn
+  #       |> configure_session(renew: true)
+  #       |> clear_session()
+  #       |> put_session(:preferred_locale, preferred_locale)
+  #     end
+  #
+  defp renew_session(conn, _admin) do
+    delete_csrf_token()
+
+    conn
+    |> configure_session(renew: true)
+    |> clear_session()
+  end
+
+  defp maybe_write_remember_me_cookie(conn, token, %{"remember_me" => "true"}, _),
+    do: write_remember_me_cookie(conn, token)
+
+  defp maybe_write_remember_me_cookie(conn, token, _params, true),
+    do: write_remember_me_cookie(conn, token)
+
+  defp maybe_write_remember_me_cookie(conn, _token, _params, _), do: conn
+
+  defp write_remember_me_cookie(conn, token) do
+    conn
+    |> put_session(:admin_remember_me, true)
+    |> put_resp_cookie(@remember_me_cookie, token, @remember_me_options)
+  end
+
+  defp put_token_in_session(conn, token) do
+    put_session(conn, :admin_token, token)
+  end
+
+  @doc """
+  Plug for routes that require sudo mode.
+  """
+  def require_sudo_mode(conn, _opts) do
+    if Admins.sudo_mode?(conn.assigns.current_scope.admin, -10) do
+      conn
+    else
+      conn
+      |> put_flash(:error, "You must re-authenticate to access this page.")
+      |> maybe_store_return_to()
+      |> redirect(to: ~p"/admins/log-in")
+      |> halt()
+    end
+  end
+
+  @doc """
+  Plug for routes that require the admin to not be authenticated.
+  """
+  def redirect_if_admin_is_authenticated(conn, _opts) do
+    if conn.assigns.current_scope do
+      conn
+      |> redirect(to: signed_in_path(conn))
+      |> halt()
+    else
+      conn
+    end
+  end
+
+  defp signed_in_path(_conn), do: ~p"/"
+
+  @doc """
+  Plug for routes that require the admin to be authenticated.
+  """
+  def require_authenticated_admin(conn, _opts) do
+    if conn.assigns.current_scope && conn.assigns.current_scope.admin do
+      conn
+    else
+      conn
+      |> put_flash(:error, "You must log in to access this page.")
+      |> maybe_store_return_to()
+      |> redirect(to: ~p"/admins/log-in")
+      |> halt()
+    end
+  end
+
+  defp maybe_store_return_to(%{method: "GET"} = conn) do
+    put_session(conn, :admin_return_to, current_path(conn))
+  end
+
+  defp maybe_store_return_to(conn), do: conn
+end

lib/beet_round_server_web/controllers/admin_controller.ex

@@ -0,0 +1,56 @@
+defmodule BeetRoundServerWeb.AdminController do
+  use BeetRoundServerWeb, :controller
+
+  alias BeetRoundServer.Admins
+  alias BeetRoundServer.Admins.Admin
+
+  action_fallback BeetRoundServerWeb.FallbackController
+
+  def create(conn, %{"admin" => admin_params}) do
+    with {:ok, %Admin{} = admin} <- Admins.register_admin(admin_params) do
+      conn
+      |> put_status(:created)
+      |> render(:show, admin: admin)
+    else
+      {:error, _changeset} ->
+        existingAdmin = Admins.get_admin_by_email(admin_params["email"])
+
+        if existingAdmin == nil do
+          conn
+          |> put_status(:bad_request)
+          |> render(:error, %{error: "Admin could not be created!", admin: admin_params})
+        else
+          admin = %{
+            mail: existingAdmin.email,
+            id: existingAdmin.id
+          }
+
+          conn
+          |> put_status(:conflict)
+          |> render(:error, %{error: "Admin already exists!", admin: admin})
+        end
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    admin = Admins.get_admin!(id)
+    render(conn, :show, admin: admin)
+  end
+
+  def log_in(conn, %{"admin" => admin_params}) do
+    case Admins.get_admin_by_email_and_password(admin_params["email"], admin_params["password"]) do
+      nil ->
+        IO.puts("Admin couldn't be found!")
+
+        conn
+        |> put_status(:forbidden)
+        |> render(:error, %{error: "Invalid email or password!", admin: admin_params})
+
+      admin ->
+        encoded_token = Admins.create_admin_api_token(admin)
+        updated_admin = Map.put(admin, :token, encoded_token)
+
+        render(conn, :token, admin: updated_admin)
+    end
+  end
+end

lib/beet_round_server_web/controllers/admin_json.ex

@@ -0,0 +1,47 @@
+defmodule BeetRoundServerWeb.AdminJSON do
+  alias BeetRoundServer.Admins.Admin
+
+  @doc """
+  Renders a list of admins.
+  """
+  def index(%{admins: admins}) do
+    %{data: for(admin <- admins, do: data(admin))}
+  end
+
+  @doc """
+  Renders a single admin.
+  """
+  def show(%{admin: admin}) do
+    %{
+      data: data(admin)
+    }
+  end
+
+  def token(%{admin: admin}) do
+    %{
+      data: %{
+        id: admin.id,
+        email: admin.email,
+        token: admin.token
+      }
+    }
+  end
+
+  def mail_status(%{status: status}) do
+    %{data: status}
+  end
+
+  def error(%{error: error, admin: admin}) do
+    %{
+      error: error,
+      admin: admin
+    }
+  end
+
+  defp data(%Admin{} = admin) do
+    %{
+      id: admin.id,
+      email: admin.email
+    }
+  end
+end

lib/beet_round_server_web/controllers/admin_registration_controller.ex

@@ -0,0 +1,32 @@
+defmodule BeetRoundServerWeb.AdminRegistrationController do
+  use BeetRoundServerWeb, :controller
+
+  alias BeetRoundServer.Admins
+  alias BeetRoundServer.Admins.Admin
+
+  def new(conn, _params) do
+    changeset = Admins.change_admin_email(%Admin{})
+    render(conn, :new, changeset: changeset)
+  end
+
+  def create(conn, %{"admin" => admin_params}) do
+    case Admins.register_admin(admin_params) do
+      {:ok, admin} ->
+        {:ok, _} =
+          Admins.deliver_login_instructions(
+            admin,
+            &url(~p"/admins/log-in/#{&1}")
+          )
+
+        conn
+        |> put_flash(
+          :info,
+          "An email was sent to #{admin.email}, please access it to confirm your account."
+        )
+        |> redirect(to: ~p"/admins/log-in")
+
+      {:error, %Ecto.Changeset{} = changeset} ->
+        render(conn, :new, changeset: changeset)
+    end
+  end
+end

lib/beet_round_server_web/controllers/admin_registration_html.ex

@@ -0,0 +1,5 @@
+defmodule BeetRoundServerWeb.AdminRegistrationHTML do
+  use BeetRoundServerWeb, :html
+
+  embed_templates "admin_registration_html/*"
+end

lib/beet_round_server_web/controllers/admin_registration_html/new.html.heex

@@ -0,0 +1,31 @@
+<Layouts.app flash={@flash} current_scope={@current_scope}>
+  <div class="mx-auto max-w-sm">
+    <div class="text-center">
+      <.header>
+        Register for an account
+        <:subtitle>
+          Already registered?
+          <.link navigate={~p"/admins/log-in"} class="font-semibold text-brand hover:underline">
+            Log in
+          </.link>
+          to your account now.
+        </:subtitle>
+      </.header>
+    </div>
+
+    <.form :let={f} for={@changeset} action={~p"/admins/register"}>
+      <.input
+        field={f[:email]}
+        type="email"
+        label="Email"
+        autocomplete="email"
+        required
+        phx-mounted={JS.focus()}
+      />
+
+      <.button phx-disable-with="Creating account..." class="btn btn-primary w-full">
+        Create an account
+      </.button>
+    </.form>
+  </div>
+</Layouts.app>

lib/beet_round_server_web/controllers/admin_session_controller.ex

@@ -0,0 +1,88 @@
+defmodule BeetRoundServerWeb.AdminSessionController do
+  use BeetRoundServerWeb, :controller
+
+  alias BeetRoundServer.Admins
+  alias BeetRoundServerWeb.AdminAuth
+
+  def new(conn, _params) do
+    email = get_in(conn.assigns, [:current_scope, Access.key(:admin), Access.key(:email)])
+    form = Phoenix.Component.to_form(%{"email" => email}, as: "admin")
+
+    render(conn, :new, form: form)
+  end
+
+  # magic link login
+  def create(conn, %{"admin" => %{"token" => token} = admin_params} = params) do
+    info =
+      case params do
+        %{"_action" => "confirmed"} -> "Admin confirmed successfully."
+        _ -> "Welcome back!"
+      end
+
+    case Admins.login_admin_by_magic_link(token) do
+      {:ok, {admin, _expired_tokens}} ->
+        conn
+        |> put_flash(:info, info)
+        |> AdminAuth.log_in_admin(admin, admin_params)
+
+      {:error, :not_found} ->
+        conn
+        |> put_flash(:error, "The link is invalid or it has expired.")
+        |> render(:new, form: Phoenix.Component.to_form(%{}, as: "admin"))
+    end
+  end
+
+  # email + password login
+  def create(conn, %{"admin" => %{"email" => email, "password" => password} = admin_params}) do
+    if admin = Admins.get_admin_by_email_and_password(email, password) do
+      conn
+      |> put_flash(:info, "Welcome back!")
+      |> AdminAuth.log_in_admin(admin, admin_params)
+    else
+      form = Phoenix.Component.to_form(admin_params, as: "admin")
+
+      # In order to prevent user enumeration attacks, don't disclose whether the email is registered.
+      conn
+      |> put_flash(:error, "Invalid email or password")
+      |> render(:new, form: form)
+    end
+  end
+
+  # magic link request
+  def create(conn, %{"admin" => %{"email" => email}}) do
+    if admin = Admins.get_admin_by_email(email) do
+      Admins.deliver_login_instructions(
+        admin,
+        &url(~p"/admins/log-in/#{&1}")
+      )
+    end
+
+    info =
+      "If your email is in our system, you will receive instructions for logging in shortly."
+
+    conn
+    |> put_flash(:info, info)
+    |> redirect(to: ~p"/admins/log-in")
+  end
+
+  def confirm(conn, %{"token" => token}) do
+    if admin = Admins.get_admin_by_magic_link_token(token) do
+      form = Phoenix.Component.to_form(%{"token" => token}, as: "admin")
+
+      conn
+      |> assign(:admin, admin)
+      |> assign(:form, form)
+      |> render(:confirm)
+    else
+      conn
+      |> put_flash(:error, "Magic link is invalid or it has expired.")
+      |> redirect(to: ~p"/admins/log-in")
+    end
+  end
+
+  def delete(conn, _params) do
+    conn
+    |> put_flash(:info, "Logged out successfully.")
+    |> AdminAuth.log_out_admin()
+  end
+end

lib/beet_round_server_web/controllers/admin_session_html.ex

@@ -0,0 +1,9 @@
+defmodule BeetRoundServerWeb.AdminSessionHTML do
+  use BeetRoundServerWeb, :html
+
+  embed_templates "admin_session_html/*"
+
+  defp local_mail_adapter? do
+    Application.get_env(:beet_round_server, BeetRoundServer.Mailer)[:adapter] == Swoosh.Adapters.Local
+  end
+end

lib/beet_round_server_web/controllers/admin_session_html/confirm.html.heex

@@ -0,0 +1,59 @@
+<Layouts.app flash={@flash} current_scope={@current_scope}>
+  <div class="mx-auto max-w-sm">
+    <div class="text-center">
+      <.header>Welcome {@admin.email}</.header>
+    </div>
+
+    <.form
+      :if={!@admin.confirmed_at}
+      for={@form}
+      id="confirmation_form"
+      action={~p"/admins/log-in?_action=confirmed"}
+      phx-mounted={JS.focus_first()}
+    >
+      <input type="hidden" name={@form[:token].name} value={@form[:token].value} />
+      <.button
+        name={@form[:remember_me].name}
+        value="true"
+        phx-disable-with="Confirming..."
+        class="btn btn-primary w-full"
+      >
+        Confirm and stay logged in
+      </.button>
+      <.button phx-disable-with="Confirming..." class="btn btn-primary btn-soft w-full mt-2">
+        Confirm and log in only this time
+      </.button>
+    </.form>
+
+    <.form
+      :if={@admin.confirmed_at}
+      for={@form}
+      id="login_form"
+      action={~p"/admins/log-in"}
+      phx-mounted={JS.focus_first()}
+    >
+      <input type="hidden" name={@form[:token].name} value={@form[:token].value} />
+      <%= if @current_scope do %>
+        <.button variant="primary" phx-disable-with="Logging in..." class="btn btn-primary w-full">
+          Log in
+        </.button>
+      <% else %>
+        <.button
+          name={@form[:remember_me].name}
+          value="true"
+          phx-disable-with="Logging in..."
+          class="btn btn-primary w-full"
+        >
+          Keep me logged in on this device
+        </.button>
+        <.button phx-disable-with="Logging in..." class="btn btn-primary btn-soft w-full mt-2">
+          Log me in only this time
+        </.button>
+      <% end %>
+    </.form>
+
+    <p :if={!@admin.confirmed_at} class="alert alert-outline mt-8">
+      Tip: If you prefer passwords, you can enable them in the admin settings.
+    </p>
+  </div>
+</Layouts.app>

lib/beet_round_server_web/controllers/admin_session_html/new.html.heex

@@ -0,0 +1,70 @@
+<Layouts.app flash={@flash} current_scope={@current_scope}>
+  <div class="mx-auto max-w-sm space-y-4">
+    <div class="text-center">
+      <.header>
+        <p>Log in</p>
+        <:subtitle>
+          <%= if @current_scope do %>
+            You need to reauthenticate to perform sensitive actions on your account.
+          <% else %>
+            Don't have an account? <.link
+              navigate={~p"/admins/register"}
+              class="font-semibold text-brand hover:underline"
+              phx-no-format
+            >Sign up</.link> for an account now.
+          <% end %>
+        </:subtitle>
+      </.header>
+    </div>
+
+    <div :if={local_mail_adapter?()} class="alert alert-info">
+      <.icon name="hero-information-circle" class="size-6 shrink-0" />
+      <div>
+        <p>You are running the local mail adapter.</p>
+        <p>
+          To see sent emails, visit <.link href="/dev/mailbox" class="underline">the mailbox page</.link>.
+        </p>
+      </div>
+    </div>
+
+    <.form :let={f} for={@form} as={:admin} id="login_form_magic" action={~p"/admins/log-in"}>
+      <.input
+        readonly={!!@current_scope}
+        field={f[:email]}
+        type="email"
+        label="Email"
+        autocomplete="email"
+        required
+        phx-mounted={JS.focus()}
+      />
+      <.button class="btn btn-primary w-full">
+        Log in with email <span aria-hidden="true">→</span>
+      </.button>
+    </.form>
+
+    <div class="divider">or</div>
+
+    <.form :let={f} for={@form} as={:admin} id="login_form_password" action={~p"/admins/log-in"}>
+      <.input
+        readonly={!!@current_scope}
+        field={f[:email]}
+        type="email"
+        label="Email"
+        autocomplete="email"
+        required
+      />
+      <.input
+        field={f[:password]}
+        type="password"
+        label="Password"
+        autocomplete="current-password"
+      />
+      <.button class="btn btn-primary w-full" name={@form[:remember_me].name} value="true">
+        Log in and stay logged in <span aria-hidden="true">→</span>
+      </.button>
+      <.button class="btn btn-primary btn-soft w-full mt-2">
+        Log in only this time
+      </.button>
+    </.form>
+  </div>
+</Layouts.app>

lib/beet_round_server_web/controllers/admin_settings_controller.ex

@@ -0,0 +1,77 @@
+defmodule BeetRoundServerWeb.AdminSettingsController do
+  use BeetRoundServerWeb, :controller
+
+  alias BeetRoundServer.Admins
+  alias BeetRoundServerWeb.AdminAuth
+
+  import BeetRoundServerWeb.AdminAuth, only: [require_sudo_mode: 2]
+
+  plug :require_sudo_mode
+  plug :assign_email_and_password_changesets
+
+  def edit(conn, _params) do
+    render(conn, :edit)
+  end
+
+  def update(conn, %{"action" => "update_email"} = params) do
+    %{"admin" => admin_params} = params
+    admin = conn.assigns.current_scope.admin
+
+    case Admins.change_admin_email(admin, admin_params) do
+      %{valid?: true} = changeset ->
+        Admins.deliver_admin_update_email_instructions(
+          Ecto.Changeset.apply_action!(changeset, :insert),
+          admin.email,
+          &url(~p"/admins/settings/confirm-email/#{&1}")
+        )
+
+        conn
+        |> put_flash(
+          :info,
+          "A link to confirm your email change has been sent to the new address."
+        )
+        |> redirect(to: ~p"/admins/settings")
+
+      changeset ->
+        render(conn, :edit, email_changeset: %{changeset | action: :insert})
+    end
+  end
+
+  def update(conn, %{"action" => "update_password"} = params) do
+    %{"admin" => admin_params} = params
+    admin = conn.assigns.current_scope.admin
+
+    case Admins.update_admin_password(admin, admin_params) do
+      {:ok, {admin, _}} ->
+        conn
+        |> put_flash(:info, "Password updated successfully.")
+        |> put_session(:admin_return_to, ~p"/admins/settings")
+        |> AdminAuth.log_in_admin(admin)
+
+      {:error, changeset} ->
+        render(conn, :edit, password_changeset: changeset)
+    end
+  end
+
+  def confirm_email(conn, %{"token" => token}) do
+    case Admins.update_admin_email(conn.assigns.current_scope.admin, token) do
+      {:ok, _admin} ->
+        conn
+        |> put_flash(:info, "Email changed successfully.")
+        |> redirect(to: ~p"/admins/settings")
+
+      {:error, _} ->
+        conn
+        |> put_flash(:error, "Email change link is invalid or it has expired.")
+        |> redirect(to: ~p"/admins/settings")
+    end
+  end
+
+  defp assign_email_and_password_changesets(conn, _opts) do
+    admin = conn.assigns.current_scope.admin
+
+    conn
+    |> assign(:email_changeset, Admins.change_admin_email(admin))
+    |> assign(:password_changeset, Admins.change_admin_password(admin))
+  end
+end

lib/beet_round_server_web/controllers/admin_settings_html.ex

@@ -0,0 +1,5 @@
+defmodule BeetRoundServerWeb.AdminSettingsHTML do
+  use BeetRoundServerWeb, :html
+
+  embed_templates "admin_settings_html/*"
+end

lib/beet_round_server_web/controllers/admin_settings_html/edit.html.heex

@@ -0,0 +1,40 @@
+<Layouts.app flash={@flash} current_scope={@current_scope}>
+  <div class="text-center">
+    <.header>
+      Account Settings
+      <:subtitle>Manage your account email address and password settings</:subtitle>
+    </.header>
+  </div>
+
+  <.form :let={f} for={@email_changeset} action={~p"/admins/settings"} id="update_email">
+    <input type="hidden" name="action" value="update_email" />
+
+    <.input field={f[:email]} type="email" label="Email" autocomplete="email" required />
+
+    <.button variant="primary" phx-disable-with="Changing...">Change Email</.button>
+  </.form>
+
+  <div class="divider" />
+
+  <.form :let={f} for={@password_changeset} action={~p"/admins/settings"} id="update_password">
+    <input type="hidden" name="action" value="update_password" />
+
+    <.input
+      field={f[:password]}
+      type="password"
+      label="New password"
+      autocomplete="new-password"
+      required
+    />
+    <.input
+      field={f[:password_confirmation]}
+      type="password"
+      label="Confirm new password"
+      autocomplete="new-password"
+      required
+    />
+    <.button variant="primary" phx-disable-with="Changing...">
+      Save Password
+    </.button>
+  </.form>
+</Layouts.app>

lib/beet_round_server_web/router.ex

@@ -1,6 +1,8 @@
 defmodule BeetRoundServerWeb.Router do
   use BeetRoundServerWeb, :router
 
+  import BeetRoundServerWeb.AdminAuth
+
   import BeetRoundServerWeb.UserAuth
 
   pipeline :browser do
@@ -10,6 +12,7 @@ defmodule BeetRoundServerWeb.Router do
     plug :put_root_layout, html: {BeetRoundServerWeb.Layouts, :root}
     plug :protect_from_forgery
     plug :put_secure_browser_headers
+    plug :fetch_current_scope_for_admin
     plug :fetch_current_scope_for_user
   end
 
@@ -23,6 +26,12 @@ defmodule BeetRoundServerWeb.Router do
     get "/", PageController, :home
   end
 
+  scope "/api", BeetRoundServerWeb do
+    pipe_through :api
+    post "/log_in", AdminController, :log_in
+    post "/admin_create", AdminController, :create
+  end
+
   # Other scopes may use custom stacks.
   scope "/api", BeetRoundServerWeb do
     pipe_through :api
@@ -93,4 +102,30 @@ defmodule BeetRoundServerWeb.Router do
 
     get "/log_in/:token", UserSessionController, :login
   end
+
+  ## Authentication routes
+
+  scope "/", BeetRoundServerWeb do
+    pipe_through [:browser, :redirect_if_admin_is_authenticated]
+
+    get "/admins/register", AdminRegistrationController, :new
+    post "/admins/register", AdminRegistrationController, :create
+  end
+
+  scope "/", BeetRoundServerWeb do
+    pipe_through [:browser, :require_authenticated_admin]
+
+    get "/admins/settings", AdminSettingsController, :edit
+    put "/admins/settings", AdminSettingsController, :update
+    get "/admins/settings/confirm-email/:token", AdminSettingsController, :confirm_email
+  end
+
+  scope "/", BeetRoundServerWeb do
+    pipe_through [:browser]
+
+    get "/admins/log-in", AdminSessionController, :new
+    get "/admins/log-in/:token", AdminSessionController, :confirm
+    post "/admins/log-in", AdminSessionController, :create
+    delete "/admins/log-out", AdminSessionController, :delete
+  end
 end