{:flop, "~> 0.26"},

      {:flop_phoenix, "~> 0.25"},

      "assets.build": [

        "compile",

        "tailwind my_app",

        "tailwind my_app_admin",

        "esbuild my_app",

        "esbuild my_app_admin"

      ],

        "tailwind my_app_admin --minify",

        "esbuild my_app_admin --minify",

{

  "dependencies": {

    "@phx-hook/copy-to-clipboard": "^0.1.3"

  }

}

## Admin

The admin panel is available at [`localhost:4000/admin`](http://localhost:4000/admin). It uses passwordless magic link authentication with an email allowlist.

Configure allowed admin emails in `config/dev.exs`:

```elixir

config :my_app, MyAppAdmin,

  allowed_emails: [~r/.+/],  # allow all in dev

  session_duration_days: 30

```

In production, replace `~r/.+/` with specific emails or patterns:

```elixir

config :my_app, MyAppAdmin,

  allowed_emails: ["admin@example.com", ~r/@mycompany\.com$/]

```

Admin users are auto-provisioned on first login if their email matches the allowlist.

/* See the Tailwind configuration guide for advanced usage

   https://tailwindcss.com/docs/configuration */

@import "tailwindcss" source(none);

@source "../css";

@source "../js";

@source "../../lib/my_app_admin_web";

/* A Tailwind plugin that makes "hero-#{ICON}" classes available.

   The heroicons installation itself is managed by your mix.exs */

@plugin "../vendor/heroicons";

/* daisyUI Tailwind Plugin. You can update this file by fetching the latest version with:

   curl -sLO https://github.com/saadeghi/daisyui/releases/latest/download/daisyui.js

   Make sure to look at the daisyUI changelog: https://daisyui.com/docs/changelog/ */

@plugin "../vendor/daisyui" {

  themes: false;

}

/* daisyUI theme plugin. You can update this file by fetching the latest version with:

  curl -sLO https://github.com/saadeghi/daisyui/releases/latest/download/daisyui-theme.js

  We ship with two themes, a light one inspired on Phoenix colors and a dark one inspired

  on Elixir colors. Build your own at: https://daisyui.com/theme-generator/ */

@plugin "../vendor/daisyui-theme" {

  name: "dark";

  default: false;

  prefersdark: true;

  color-scheme: "dark";

  --color-base-100: oklch(30.33% 0.016 252.42);

  --color-base-200: oklch(25.26% 0.014 253.1);

  --color-base-300: oklch(20.15% 0.012 254.09);

  --color-base-content: oklch(97.807% 0.029 256.847);

  --color-primary: oklch(58% 0.233 277.117);

  --color-primary-content: oklch(96% 0.018 272.314);

  --color-secondary: oklch(58% 0.233 277.117);

  --color-secondary-content: oklch(96% 0.018 272.314);

  --color-accent: oklch(60% 0.25 292.717);

  --color-accent-content: oklch(96% 0.016 293.756);

  --color-neutral: oklch(37% 0.044 257.287);

  --color-neutral-content: oklch(98% 0.003 247.858);

  --color-info: oklch(58% 0.158 241.966);

  --color-info-content: oklch(97% 0.013 236.62);

  --color-success: oklch(60% 0.118 184.704);

  --color-success-content: oklch(98% 0.014 180.72);

  --color-warning: oklch(66% 0.179 58.318);

  --color-warning-content: oklch(98% 0.022 95.277);

  --color-error: oklch(58% 0.253 17.585);

  --color-error-content: oklch(96% 0.015 12.422);

  --radius-selector: 0.25rem;

  --radius-field: 0.25rem;

  --radius-box: 0.5rem;

  --size-selector: 0.21875rem;

  --size-field: 0.21875rem;

  --border: 1.5px;

  --depth: 1;

  --noise: 0;

}

@plugin "../vendor/daisyui-theme" {

  name: "light";

  default: true;

  prefersdark: false;

  color-scheme: "light";

  --color-base-100: oklch(98% 0 0);

  --color-base-200: oklch(96% 0.001 286.375);

  --color-base-300: oklch(92% 0.004 286.32);

  --color-base-content: oklch(21% 0.006 285.885);

  --color-primary: oklch(70% 0.213 47.604);

  --color-primary-content: oklch(98% 0.016 73.684);

  --color-secondary: oklch(55% 0.027 264.364);

  --color-secondary-content: oklch(98% 0.002 247.839);

  --color-accent: oklch(0% 0 0);

  --color-accent-content: oklch(100% 0 0);

  --color-neutral: oklch(44% 0.017 285.786);

  --color-neutral-content: oklch(98% 0 0);

  --color-info: oklch(62% 0.214 259.815);

  --color-info-content: oklch(97% 0.014 254.604);

  --color-success: oklch(70% 0.14 182.503);

  --color-success-content: oklch(98% 0.014 180.72);

  --color-warning: oklch(66% 0.179 58.318);

  --color-warning-content: oklch(98% 0.022 95.277);

  --color-error: oklch(58% 0.253 17.585);

  --color-error-content: oklch(96% 0.015 12.422);

  --radius-selector: 0.25rem;

  --radius-field: 0.25rem;

  --radius-box: 0.5rem;

  --size-selector: 0.21875rem;

  --size-field: 0.21875rem;

  --border: 1.5px;

  --depth: 1;

  --noise: 0;

}

/* Copied state variant for copy-to-clipboard hook */

@custom-variant copied ([data-copied]&, [data-copied] &);

/* Add variants based on LiveView classes */

@custom-variant phx-click-loading (.phx-click-loading&, .phx-click-loading &);

@custom-variant phx-submit-loading (.phx-submit-loading&, .phx-submit-loading &);

@custom-variant phx-change-loading (.phx-change-loading&, .phx-change-loading &);

/* Use the data attribute for dark mode  */

@custom-variant dark (&:where([data-theme=dark], [data-theme=dark] *));

/* Make LiveView wrapper divs transparent for layout */

[data-phx-session], [data-phx-teleported-src] { display: contents }

/* This file is for your admin application CSS */

// Include phoenix_html to handle method=PUT/DELETE in forms and buttons.

import "phoenix_html"

// Establish Phoenix Socket and LiveView configuration.

import {Socket} from "phoenix"

import {LiveSocket} from "phoenix_live_view"

import {hooks as colocatedHooks} from "phoenix-colocated/my_app"

import CopyToClipboardHook from "@phx-hook/copy-to-clipboard"

import topbar from "../vendor/topbar"

const csrfToken = document.querySelector("meta[name='csrf-token']").getAttribute("content")

const liveSocket = new LiveSocket("/live", Socket, {

  longPollFallbackMs: 2500,

  params: {_csrf_token: csrfToken},

  hooks: {...colocatedHooks, CopyToClipboard: CopyToClipboardHook()},

})

// Show progress bar on live navigation and form submits

topbar.config({barColors: {0: "#29d"}, shadowColor: "rgba(0, 0, 0, .3)"})

window.addEventListener("phx:page-loading-start", _info => topbar.show(300))

window.addEventListener("phx:page-loading-stop", _info => topbar.hide())

// connect if there are any LiveViews on the page

liveSocket.connect()

// expose liveSocket on window for web console debug logs and latency simulation:

// >> liveSocket.enableDebug()

// >> liveSocket.enableLatencySim(1000)  // enabled for duration of browser session

// >> liveSocket.disableLatencySim()

window.liveSocket = liveSocket

// The lines below enable quality of life phoenix_live_reload

// development features:

//

//     1. stream server logs to the browser console

//     2. click on elements to jump to their definitions in your code editor

//

if (process.env.NODE_ENV === "development") {

  window.addEventListener("phx:live_reload:attached", ({detail: reloader}) => {

    // Enable server log streaming to client.

    // Disable with reloader.disableServerLogs()

    reloader.enableServerLogs()

    // Open configured PLUG_EDITOR at file:line of the clicked element's HEEx component

    //

    //   * click with "c" key pressed to open at caller location

    //   * click with "d" key pressed to open at function component definition location

    let keyDown

    window.addEventListener("keydown", e => keyDown = e.key)

    window.addEventListener("keyup", _e => keyDown = null)

    window.addEventListener("click", e => {

      if(keyDown === "c"){

        e.preventDefault()

        e.stopImmediatePropagation()

        reloader.openEditorAtCaller(e.target)

      } else if(keyDown === "d"){

        e.preventDefault()

        e.stopImmediatePropagation()

        reloader.openEditorAtDef(e.target)

      }

    }, true)

    window.liveReloader = reloader

  })

}

config :my_app, MyAppAdmin,

  allowed_emails: [],

  session_duration_days: 30

config :flop, repo: MyApp.Repo

  ],

  my_app_admin: [

    args:

      ~w(js/admin.js --bundle --target=es2022 --outdir=../priv/static/assets/js --external:/fonts/* --external:/images/* --alias:@=.),

    cd: Path.expand("../assets", __DIR__),

    env: %{"NODE_PATH" => [Path.expand("../deps", __DIR__), Mix.Project.build_path()]}

  ],

  my_app_admin: [

    args: ~w(

      --input=assets/css/admin.css

      --output=priv/static/assets/css/admin.css

    ),

    cd: Path.expand("..", __DIR__)

config :my_app, MyAppAdmin,

  allowed_emails: [~r/.+/],

  session_duration_days: 30

    tailwind: {Tailwind, :install_and_run, [:my_app, ~w(--watch)]},

    esbuild: {Esbuild, :install_and_run, [:my_app_admin, ~w(--sourcemap=inline --watch)]},

    tailwind: {Tailwind, :install_and_run, [:my_app_admin, ~w(--watch)]}

      ~r"lib/my_app_web/(controllers|live|components)/.*\.(ex|heex)$",

      ~r"lib/my_app_admin_web/(controllers|live|components)/.*\.(ex|heex)$"

  defstruct user: nil, impersonated_by: nil

  def for_user(user, opts \\ [])

  def for_user(%User{} = user, opts) do

    %__MODULE__{user: user, impersonated_by: Keyword.get(opts, :impersonated_by)}

  def for_user(nil, _opts), do: nil

  @doc """

  Returns true if the scope represents an impersonated session.

  """

  def impersonating?(%__MODULE__{impersonated_by: admin}) when not is_nil(admin), do: true

  def impersonating?(_), do: false

defmodule MyAppAdmin.Accounts do

  @moduledoc """

  The Admin Accounts context.

  """

  import Ecto.Query, warn: false

  alias MyApp.Repo

  alias MyAppAdmin.Accounts.AdminUser

  alias MyAppAdmin.Accounts.AdminUserNotifier

  alias MyAppAdmin.Accounts.AdminUserToken

  @doc """

  Gets an admin user by email.

  """

  def get_admin_user_by_email(email) when is_binary(email) do

    Repo.get_by(AdminUser, email: email)

  end

  ## Allowlist

  @doc """

  Checks if an email is allowed to log in as admin.

  Compares against the `:allowed_emails` config, which can contain

  string emails or regex patterns.

  """

  def email_allowed?(email) when is_binary(email) do

    config = Application.get_env(:my_app, MyAppAdmin, [])

    allowed = Keyword.get(config, :allowed_emails, [])

    Enum.any?(allowed, fn

      %Regex{} = regex -> Regex.match?(regex, email)

      string when is_binary(string) -> string == email

    end)

  end

  ## Provisioning

  @doc """

  Gets an existing admin user by email, or creates one if the email is allowed.

  """

  def get_or_create_admin_user_by_email!(email) when is_binary(email) do

    case Repo.get_by(AdminUser, email: email) do

      %AdminUser{} = admin_user ->

        admin_user

      nil ->

        %AdminUser{}

        |> AdminUser.email_changeset(%{email: email})

        |> Repo.insert!()

    end

  end

  ## Session

  @doc """

  Generates a session token.

  """

  def generate_admin_user_session_token(admin_user) do

    {token, admin_user_token} = AdminUserToken.build_session_token(admin_user)

    Repo.insert!(admin_user_token)

    token

  end

  @doc """

  Gets the admin user with the given signed token.

  """

  def get_admin_user_by_session_token(token) do

    {:ok, query} = AdminUserToken.verify_session_token_query(token)

    Repo.one(query)

  end

  @doc """

  Gets an admin user by magic link token without consuming it.

  Used for the confirmation page.

  """

  def get_admin_user_by_magic_link_token(token) do

    with {:ok, query} <- AdminUserToken.verify_magic_link_token_query(token),

         {admin_user, _token} <- Repo.one(query) do

      admin_user

    else

      _ -> nil

    end

  end

  @doc """

  Logs in an admin user by magic link token.

  Verifies the token and deletes it. Returns `{:ok, admin_user}` or `{:error, :not_found}`.

  """

  def login_admin_user_by_magic_link(token) do

    {:ok, query} = AdminUserToken.verify_magic_link_token_query(token)

    case Repo.one(query) do

      {admin_user, token} ->

        Repo.delete!(token)

        {:ok, {admin_user, []}}

      nil ->

        {:error, :not_found}

    end

  end

  @doc """

  Delivers the magic link login instructions to the given admin user.

  """

  def deliver_login_instructions(%AdminUser{} = admin_user, magic_link_url_fun)

      when is_function(magic_link_url_fun, 1) do

    {token, admin_user_token} = AdminUserToken.build_email_token(admin_user, "login")

    Repo.insert!(admin_user_token)

    AdminUserNotifier.deliver_magic_link_instructions(admin_user, magic_link_url_fun.(token))

  end

  @doc """

  Deletes the signed token with the given context.

  """

  def delete_admin_user_session_token(token) do

    Repo.delete_all(AdminUserToken.by_token_and_context_query(token, "session"))

    :ok

  end

end

defmodule MyAppAdmin.Accounts.AdminUser do

  use Ecto.Schema

  import Ecto.Changeset

  @primary_key {:id, :binary_id, autogenerate: true}

  @foreign_key_type :binary_id

  schema "admin_users" do

    field :email, :string

    timestamps(type: :utc_datetime)

  end

  @doc """

  A admin user changeset for registering or changing the email.

  """

  def email_changeset(admin_user, attrs, opts \\ []) do

    admin_user

    |> cast(attrs, [:email])

    |> validate_email(opts)

  end

  defp validate_email(changeset, opts) do

    changeset =

      changeset

      |> validate_required([:email])

      |> validate_format(:email, ~r/^[^@,;\s]+@[^@,;\s]+$/,

        message: "must have the @ sign and no spaces"

      )

      |> validate_length(:email, max: 160)

    if Keyword.get(opts, :validate_unique, true) do

      changeset

      |> unsafe_validate_unique(:email, MyApp.Repo)

      |> unique_constraint(:email)

    else

      changeset

    end

  end

end

defmodule MyAppAdmin.Accounts.AdminUserNotifier do

  import Swoosh.Email

  alias MyApp.Mailer

  defp deliver(recipient, subject, body) do

    email =

      new()

      |> to(recipient)

      |> from({"MyApp", "contact@example.com"})

      |> subject(subject)

      |> text_body(body)

    with {:ok, _metadata} <- Mailer.deliver(email) do

      {:ok, email}

    end

  end

  @doc """

  Deliver magic link login instructions to an admin user.

  """

  def deliver_magic_link_instructions(admin_user, url) do

    deliver(admin_user.email, "Admin login link", """

    ==============================

    Hi #{admin_user.email},

    You can log into the admin area by visiting the URL below:

    #{url}

    If you didn't request this email, please ignore this.

    ==============================

    """)

  end

end

defmodule MyAppAdmin.Accounts.AdminUserToken do

  use Ecto.Schema

  import Ecto.Query

  @hash_algorithm :sha256

  @rand_size 32

  @magic_link_validity_in_minutes 15

  @primary_key {:id, :binary_id, autogenerate: true}

  @foreign_key_type :binary_id

  schema "admin_users_tokens" do

    field :token, :binary

    field :context, :string

    field :sent_to, :string

    belongs_to :admin_user, MyAppAdmin.Accounts.AdminUser

    timestamps(type: :utc_datetime, updated_at: false)

  end

  @doc """

  Generates a session token.

  """

  def build_session_token(admin_user) do

    token = :crypto.strong_rand_bytes(@rand_size)

    {token, %__MODULE__{token: token, context: "session", admin_user_id: admin_user.id}}

  end

  @doc """

  Checks if the token is valid and returns its underlying lookup query.

  The query returns the admin user found by the token, if any.

  """

  def verify_session_token_query(token) do

    query =

      from token in by_token_and_context_query(token, "session"),

        join: admin_user in assoc(token, :admin_user),

        where: token.inserted_at > ago(^session_validity_in_days(), "day"),

        select: admin_user

    {:ok, query}

  end

  defp session_validity_in_days do

    config = Application.get_env(:my_app, MyAppAdmin, [])

    Keyword.get(config, :session_duration_days, 30)

  end

  @doc """

  Builds a token and its hash to be delivered to the admin user's email.

  The non-hashed token is sent to the user email while the

  hashed part is stored in the database.

  """

  def build_email_token(admin_user, context) do

    build_hashed_token(admin_user, context, admin_user.email)

  end

  defp build_hashed_token(admin_user, context, sent_to) do

    token = :crypto.strong_rand_bytes(@rand_size)

    hashed_token = :crypto.hash(@hash_algorithm, token)

    {Base.url_encode64(token, padding: false),

     %__MODULE__{

       token: hashed_token,

       context: context,

       sent_to: sent_to,

       admin_user_id: admin_user.id

     }}

  end

  @doc """

  Checks if the magic link token is valid and returns its underlying lookup query.

  The token is valid if it matches its hashed counterpart in the database,

  has not expired (15 minutes), and the sent_to matches the admin user's email.

  """

  def verify_magic_link_token_query(token) do

    case Base.url_decode64(token, padding: false) do

      {:ok, decoded_token} ->

        hashed_token = :crypto.hash(@hash_algorithm, decoded_token)

        query =

          from token in by_token_and_context_query(hashed_token, "login"),

            join: admin_user in assoc(token, :admin_user),

            where: token.inserted_at > ago(^@magic_link_validity_in_minutes, "minute"),

            where: token.sent_to == admin_user.email,

            select: {admin_user, token}

        {:ok, query}

      :error ->

        :error

    end

  end

  @doc """

  Returns the token struct for the given token value and context.

  """

  def by_token_and_context_query(token, context) do

    from __MODULE__, where: [token: ^token, context: ^context]

  end

end

defmodule MyAppAdmin.Accounts.Scope do

  @moduledoc """

  Defines the scope of the caller for admin operations.

  """

  alias MyAppAdmin.Accounts.AdminUser

  defstruct admin_user: nil

  @doc """

  Creates a scope for the given admin user.

  """

  def for_admin_user(%AdminUser{} = admin_user) do

    %__MODULE__{admin_user: admin_user}

  end

  def for_admin_user(nil), do: nil

end

defmodule MyAppAdmin.Query do

  def default_flop_opts do

    [

      filterable: [:email],

      sortable: [:email, :inserted_at],

      default_limit: 20,

      max_limit: 100,

      default_order: %{order_by: [:inserted_at], order_directions: [:desc]},

      pagination_types: [:page]

    ]

  end

end

defmodule MyAppAdmin.Query.AdminUsers do

  alias MyApp.Repo

  alias MyAppAdmin.Accounts.AdminUser

  @flop_opts MyAppAdmin.Query.default_flop_opts()

  @doc """

  Returns a paginated, sorted, and filtered list of admin users.

  Returns `{:ok, {admin_users, meta}}` or `{:error, meta}`.

  """

  def list(params \\ %{}) do

    Flop.validate_and_run(AdminUser, params, @flop_opts)

  end

  @doc """

  Gets a single admin user.

  """

  def get!(id), do: Repo.get!(AdminUser, id)

end

defmodule MyAppAdmin.Query.Users do

  alias MyApp.Repo

  alias MyApp.Accounts.User

  @flop_opts MyAppAdmin.Query.default_flop_opts()

  @doc """

  Returns a paginated, sorted, and filtered list of users.

  Returns `{:ok, {users, meta}}` or `{:error, meta}`.

  """

  def list(params \\ %{}) do

    Flop.validate_and_run(User, params, @flop_opts)

  end

  @doc """

  Gets a single user.

  """

  def get!(id), do: Repo.get!(User, id)

end

defmodule MyAppAdminWeb do

  @moduledoc """

  The entrypoint for defining the admin web interface.

  This can be used in your application as:

      use MyAppAdminWeb, :controller

      use MyAppAdminWeb, :live_view

  """

  def static_paths, do: ~w(assets fonts images favicon.ico robots.txt)

  def router do

    quote do

      use Phoenix.Router, helpers: false

      import Plug.Conn

      import Phoenix.Controller

      import Phoenix.LiveView.Router

    end

  end

  def controller do

    quote do

      use Phoenix.Controller, formats: [:html, :json]

      import Plug.Conn

      unquote(verified_routes())

    end

  end

  def live_view do

    quote do

      use Phoenix.LiveView

      unquote(html_helpers())

    end

  end

  def live_component do

    quote do

      use Phoenix.LiveComponent

      unquote(html_helpers())

    end

  end

  def html do

    quote do

      use Phoenix.Component

      import Phoenix.Controller,

        only: [get_csrf_token: 0, view_module: 1, view_template: 1]

      unquote(html_helpers())

    end

  end

  defp html_helpers do

    quote do

      import Phoenix.HTML

      import MyAppAdminWeb.CoreComponents

      alias Flop.Filter

      alias Phoenix.LiveView.JS

      alias MyAppAdminWeb.Layouts

      unquote(verified_routes())

    end

  end

  def verified_routes do

    quote do

      use Phoenix.VerifiedRoutes,

        endpoint: MyAppWeb.Endpoint,

        router: MyAppWeb.Router,

        statics: MyAppAdminWeb.static_paths()

    end

  end

  @doc """

  When used, dispatch to the appropriate controller/live_view/etc.

  """

  defmacro __using__(which) when is_atom(which) do

    apply(__MODULE__, which, [])

  end

end

defmodule MyAppAdminWeb.AdminUserAuth do

  @moduledoc """

  Handles admin user authentication for plugs and LiveView on_mount hooks.

  """

  use MyAppAdminWeb, :verified_routes

  import Plug.Conn

  import Phoenix.Controller

  alias MyAppAdmin.Accounts

  alias MyAppAdmin.Accounts.Scope

  @doc """

  Logs the admin user in.

  """

  def log_in_admin_user(conn, admin_user) do

    token = Accounts.generate_admin_user_session_token(admin_user)

    conn

    |> renew_session()

    |> put_token_in_session(token)

    |> redirect(to: signed_in_path(conn))

  end

  @doc """

  Logs the admin user out.

  """

  def log_out_admin_user(conn) do

    admin_user_token = get_session(conn, :admin_user_token)

    admin_user_token && Accounts.delete_admin_user_session_token(admin_user_token)

    if live_socket_id = get_session(conn, :live_socket_id) do

      MyAppWeb.Endpoint.broadcast(live_socket_id, "disconnect", %{})

    end

    conn

    |> renew_session()

    |> redirect(to: ~p"/admin/log-in")

  end

  @doc """

  Authenticates the admin user by looking into the session.

  """

  def fetch_current_scope_for_admin_user(conn, _opts) do

    admin_user_token = get_session(conn, :admin_user_token)

    admin_user = admin_user_token && Accounts.get_admin_user_by_session_token(admin_user_token)

    assign(conn, :current_scope, Scope.for_admin_user(admin_user))

  end

  defp renew_session(conn) do

    delete_csrf_token()

    conn

    |> configure_session(renew: true)

    |> clear_session()

  end

  defp put_token_in_session(conn, token) do

    conn

    |> put_session(:admin_user_token, token)

    |> put_session(:live_socket_id, admin_session_topic(token))

  end

  defp admin_session_topic(token), do: "admin_users_sessions:#{Base.url_encode64(token)}"

  @doc """

  Handles mounting and authenticating the current admin user in LiveViews.

  """

  def on_mount(:mount_current_scope, _params, session, socket) do

    {:cont, mount_current_scope(socket, session)}

  end

  def on_mount(:require_authenticated, _params, session, socket) do

    socket = mount_current_scope(socket, session)

    if socket.assigns.current_scope && socket.assigns.current_scope.admin_user do

      {:cont, socket}

    else

      socket =

        socket

        |> Phoenix.LiveView.put_flash(:error, "You must log in to access the admin area.")

        |> Phoenix.LiveView.redirect(to: ~p"/admin/log-in")

      {:halt, socket}

    end

  end

  def on_mount(:redirect_if_authenticated, _params, session, socket) do

    socket = mount_current_scope(socket, session)

    if socket.assigns.current_scope && socket.assigns.current_scope.admin_user do

      {:halt, Phoenix.LiveView.redirect(socket, to: signed_in_path(socket))}

    else

      {:cont, socket}

    end

  end

  defp mount_current_scope(socket, session) do

    Phoenix.Component.assign_new(socket, :current_scope, fn ->

      if admin_user_token = session["admin_user_token"] do

        Accounts.get_admin_user_by_session_token(admin_user_token)

      end

      |> Scope.for_admin_user()

    end)

  end

  def signed_in_path(_), do: ~p"/admin"

  @doc """

  Plug for routes that require the admin user to be authenticated.

  """

  def require_authenticated_admin_user(conn, _opts) do

    if conn.assigns[:current_scope] && conn.assigns.current_scope.admin_user do

      conn

    else

      conn

      |> put_flash(:error, "You must log in to access the admin area.")

      |> redirect(to: ~p"/admin/log-in")

      |> halt()

    end

  end

end

defmodule MyAppAdminWeb.CoreComponents do

  @moduledoc """

  Admin UI components.

  """

  use Phoenix.Component

  alias Phoenix.LiveView.JS

  @doc """

  Renders flash notices.

  ## Examples

      <.flash kind={:info} flash={@flash} />

      <.flash kind={:info} phx-mounted={show("#flash")}>Welcome Back!</.flash>

  """

  attr :id, :string, doc: "the optional id of flash container"

  attr :flash, :map, default: %{}, doc: "the map of flash messages to display"

  attr :title, :string, default: nil

  attr :kind, :atom, values: [:info, :error], doc: "used for styling and flash lookup"

  attr :rest, :global, doc: "the arbitrary HTML attributes to add to the flash container"

  slot :inner_block, doc: "the optional inner block that renders the flash message"

  def flash(assigns) do

    assigns = assign_new(assigns, :id, fn -> "flash-#{assigns.kind}" end)

    ~H"""

    <div

      :if={msg = render_slot(@inner_block) || Phoenix.Flash.get(@flash, @kind)}

      id={@id}

      phx-click={JS.push("lv:clear-flash", value: %{key: @kind}) |> hide("##{@id}")}

      role="alert"

      class="toast toast-top toast-end z-50"

      {@rest}

    >

      <div class={[

        "alert w-80 sm:w-96 max-w-80 sm:max-w-96 text-wrap",

        @kind == :info && "alert-info",

        @kind == :error && "alert-error"

      ]}>

        <.icon :if={@kind == :info} name="hero-information-circle" class="size-5 shrink-0" />

        <.icon :if={@kind == :error} name="hero-exclamation-circle" class="size-5 shrink-0" />

        <div>

          <p :if={@title} class="font-semibold">{@title}</p>

          <p>{msg}</p>

        </div>

        <div class="flex-1" />

        <button type="button" class="group self-start cursor-pointer" aria-label="close">

          <.icon name="hero-x-mark" class="size-5 opacity-40 group-hover:opacity-70" />

        </button>

      </div>

    </div>

    """

  end

  @doc """

  Renders a copy-to-clipboard button that displays a value and copies it on click.

  ## Examples

      <.copy_button value={@user.email} />

  """

  attr :value, :string, required: true

  def copy_button(assigns) do

    assigns = assign_new(assigns, :id, fn -> "copy-#{System.unique_integer([:positive])}" end)

    ~H"""

    <span

      id={@id}

      phx-hook="CopyToClipboard"

      data-copy-format="plain"

      data-copy-value={@value}

      data-copy-reset-after="2000"

      phx-click={JS.dispatch("phx:copy")}

      class="inline-flex items-center gap-1 cursor-pointer group"

    >

      {@value}

      <.icon

        name="hero-clipboard-document-mini"

        class="size-4 opacity-0 group-hover:opacity-100 copied:!hidden"

      />

      <.icon

        name="hero-clipboard-document-check-mini"

        class="size-4 hidden copied:!inline text-success"

      />

    </span>

    """

  end

  @doc """

  Renders a button.

  ## Examples

      <.button>Send!</.button>

      <.button phx-click="go" variant="primary">Send!</.button>

      <.button navigate={~p"/"}>Home</.button>

  """

  attr :rest, :global, include: ~w(href navigate patch method download name value disabled)

  attr :class, :any

  attr :variant, :string, values: ~w(primary)

  slot :inner_block, required: true

  def button(%{rest: rest} = assigns) do

    variants = %{"primary" => "btn-primary", nil => "btn-primary btn-soft"}

    assigns =

      assign_new(assigns, :class, fn ->

        ["btn", Map.fetch!(variants, assigns[:variant])]

      end)

    if rest[:href] || rest[:navigate] || rest[:patch] do

      ~H"""

      <.link class={@class} {@rest}>

        {render_slot(@inner_block)}

      </.link>

      """

    else

      ~H"""

      <button class={@class} {@rest}>

        {render_slot(@inner_block)}

      </button>

      """

    end

  end

  @doc """

  Renders an input with label and error messages.

  A `Phoenix.HTML.FormField` may be passed as argument,

  which is used to retrieve the input name, id, and values.

  Otherwise all attributes may be passed explicitly.

  ## Examples

      <.input field={@form[:email]} type="email" />

      <.input name="my-input" errors={["oh no!"]} />

  """

  attr :id, :any, default: nil

  attr :name, :any

  attr :label, :string, default: nil

  attr :value, :any

  attr :type, :string,

    default: "text",

    values: ~w(checkbox color date datetime-local email file month number password

               search select tel text textarea time url week hidden)

  attr :field, Phoenix.HTML.FormField,

    doc: "a form field struct retrieved from the form, for example: @form[:email]"

  attr :errors, :list, default: []

  attr :checked, :boolean, doc: "the checked flag for checkbox inputs"

  attr :prompt, :string, default: nil, doc: "the prompt for select inputs"

  attr :options, :list, doc: "the options to pass to Phoenix.HTML.Form.options_for_select/2"

  attr :multiple, :boolean, default: false, doc: "the multiple flag for select inputs"

  attr :class, :any, default: nil, doc: "the input class to use over defaults"

  attr :error_class, :any, default: nil, doc: "the input error class to use over defaults"

  attr :rest, :global,

    include: ~w(accept autocomplete capture cols disabled form list max maxlength min minlength

                multiple pattern placeholder readonly required rows size step)

  def input(%{field: %Phoenix.HTML.FormField{} = field} = assigns) do

    errors = if Phoenix.Component.used_input?(field), do: field.errors, else: []

    assigns

    |> assign(field: nil, id: assigns.id || field.id)

    |> assign(:errors, Enum.map(errors, &translate_error(&1)))

    |> assign_new(:name, fn -> if assigns.multiple, do: field.name <> "[]", else: field.name end)

    |> assign_new(:value, fn -> field.value end)

    |> input()

  end

  def input(%{type: "hidden"} = assigns) do

    ~H"""

    <input type="hidden" id={@id} name={@name} value={@value} {@rest} />

    """

  end

  def input(%{type: "checkbox"} = assigns) do

    assigns =

      assign_new(assigns, :checked, fn ->

        Phoenix.HTML.Form.normalize_value("checkbox", assigns[:value])

      end)

    ~H"""

    <div class="fieldset mb-2">

      <label>

        <input

          type="hidden"

          name={@name}

          value="false"

          disabled={@rest[:disabled]}

          form={@rest[:form]}

        />

        <span class="label">

          <input

            type="checkbox"

            id={@id}

            name={@name}

            value="true"

            checked={@checked}

            class={@class || "checkbox checkbox-sm"}

            {@rest}

          />{@label}

        </span>

      </label>

      <.error :for={msg <- @errors}>{msg}</.error>

    </div>

    """

  end

  def input(%{type: "select"} = assigns) do

    ~H"""

    <div class="fieldset mb-2">

      <label>

        <span :if={@label} class="label mb-1">{@label}</span>

        <select

          id={@id}

          name={@name}

          class={[@class || "w-full select", @errors != [] && (@error_class || "select-error")]}

          multiple={@multiple}

          {@rest}

        >

          <option :if={@prompt} value="">{@prompt}</option>

          {Phoenix.HTML.Form.options_for_select(@options, @value)}

        </select>

      </label>

      <.error :for={msg <- @errors}>{msg}</.error>

    </div>

    """

  end

  def input(%{type: "textarea"} = assigns) do

    ~H"""

    <div class="fieldset mb-2">

      <label>

        <span :if={@label} class="label mb-1">{@label}</span>

        <textarea

          id={@id}

          name={@name}

          class={[

            @class || "w-full textarea",

            @errors != [] && (@error_class || "textarea-error")

          ]}

          {@rest}

        >{Phoenix.HTML.Form.normalize_value("textarea", @value)}</textarea>

      </label>

      <.error :for={msg <- @errors}>{msg}</.error>

    </div>

    """

  end

  def input(assigns) do

    ~H"""

    <div class="fieldset mb-2">

      <label>

        <span :if={@label} class="label mb-1">{@label}</span>

        <input

          type={@type}

          name={@name}

          id={@id}

          value={Phoenix.HTML.Form.normalize_value(@type, @value)}

          class={[

            @class || "w-full input",

            @errors != [] && (@error_class || "input-error")

          ]}

          {@rest}

        />

      </label>

      <.error :for={msg <- @errors}>{msg}</.error>

    </div>

    """

  end

  defp error(assigns) do

    ~H"""

    <p class="mt-1.5 flex gap-2 items-center text-sm text-error">

      <.icon name="hero-exclamation-circle" class="size-5" />

      {render_slot(@inner_block)}

    </p>

    """

  end

  @doc """

  Renders a header with title.

  """

  slot :inner_block, required: true

  slot :subtitle

  slot :actions

  def header(assigns) do

    ~H"""

    <header class={[@actions != [] && "flex items-center justify-between gap-6", "pb-4"]}>

      <div>

        <h1 class="text-lg font-semibold leading-8">

          {render_slot(@inner_block)}

        </h1>

        <p :if={@subtitle != []} class="text-sm text-base-content/70">

          {render_slot(@subtitle)}

        </p>

      </div>

      <div class="flex-none">{render_slot(@actions)}</div>

    </header>

    """

  end

  @doc """

  Renders a table with generic styling.

  ## Examples

      <.table id="users" rows={@users}>

        <:col :let={user} label="id">{user.id}</:col>

        <:col :let={user} label="username">{user.username}</:col>

      </.table>

  """

  attr :id, :string, required: true

  attr :rows, :list, required: true

  attr :row_id, :any, default: nil, doc: "the function for generating the row id"

  attr :row_click, :any, default: nil, doc: "the function for handling phx-click on each row"

  attr :row_item, :any,

    default: &Function.identity/1,

    doc: "the function for mapping each row before calling the :col and :action slots"

  slot :col, required: true do

    attr :label, :string

  end

  slot :action, doc: "the slot for showing user actions in the last table column"

  def table(assigns) do

    assigns =

      with %{rows: %Phoenix.LiveView.LiveStream{}} <- assigns do

        assign(assigns, row_id: assigns.row_id || fn {id, _item} -> id end)

      end

    ~H"""

    <table class="table">

      <thead>

        <tr>

          <th :for={col <- @col}>{col[:label]}</th>

          <th :if={@action != []}>

            <span class="sr-only">Actions</span>

          </th>

        </tr>

      </thead>

      <tbody id={@id} phx-update={is_struct(@rows, Phoenix.LiveView.LiveStream) && "stream"}>

        <tr :for={row <- @rows} id={@row_id && @row_id.(row)}>

          <td

            :for={col <- @col}

            phx-click={@row_click && @row_click.(row)}

            class={@row_click && "hover:cursor-pointer"}

          >

            {render_slot(col, @row_item.(row))}

          </td>

          <td :if={@action != []} class="w-0 font-semibold">

            <div class="flex gap-4">

              <%= for action <- @action do %>

                {render_slot(action, @row_item.(row))}

              <% end %>

            </div>

          </td>

        </tr>

      </tbody>

    </table>

    """

  end

  @doc """

  Renders a sortable data table using Flop.Phoenix with standard admin styling.

  ## Examples

      <.data_table items={@users} meta={@meta} path={~p"/admin/users"} id="users">

        <:col :let={user} label="Email" field={:email}>{user.email}</:col>

        <:action :let={user}>

          <.link navigate={~p"/admin/users/\#{user}"}>Show</.link>

        </:action>

      </.data_table>

  """

  attr :items, :list, required: true

  attr :meta, Flop.Meta, required: true

  attr :path, :string, required: true

  attr :id, :string, required: true

  attr :row_click, :any, default: nil

  slot :col do

    attr :label, :string

    attr :field, :atom

  end

  slot :action

  def data_table(assigns) do

    ~H"""

    <div class="overflow-x-auto rounded-box border border-base-content/5 bg-base-100">

      <Flop.Phoenix.table

        items={@items}

        meta={@meta}

        path={@path}

        id={@id}

        row_click={@row_click}

        opts={[

          table_attrs: [class: "table [&_tr:hover]:bg-base-200 [&_td]:whitespace-nowrap [&_th]:whitespace-nowrap"],

          thead_attrs: [class: "[&_th]:cursor-pointer"],

          thead_th_attrs: [class: "hover:bg-base-200"]

        ]}

      >

        <:col :let={item} :for={col <- @col} label={col[:label]} field={col[:field]}>

          {render_slot(col, item)}

        </:col>

        <:action :let={item} :for={action <- @action}>

          {render_slot(action, item)}

        </:action>

      </Flop.Phoenix.table>

    </div>

    """

  end

  @doc """

  Renders DaisyUI pagination controls.

  Only renders when there is more than 1 page of results.

  ## Examples

      <.pagination meta={@meta} path={~p"/admin/users"} />

  """

  attr :meta, Flop.Meta, required: true

  attr :path, :string, required: true

  def pagination(assigns) do

    assigns = assign(assigns, :page_links, build_page_links(assigns.meta, 5))

    ~H"""

    <div :if={@meta.total_pages > 1} class="flex justify-end mt-4">

      <div class="join">

        <.link

          patch={Flop.Phoenix.build_path(@path, Flop.set_page(@meta.flop, @meta.current_page - 1))}

          class={["join-item btn btn-sm", @meta.current_page == 1 && "btn-disabled"]}

        >

          «

        </.link>

        <.link

          :for={{page, type} <- @page_links}

          patch={Flop.Phoenix.build_path(@path, Flop.set_page(@meta.flop, page))}

          class={[

            "join-item btn btn-sm",

            type == :current && "btn-active",

            type == :ellipsis && "btn-disabled"

          ]}

        >

          {if type == :ellipsis, do: "…", else: page}

        </.link>

        <.link

          patch={Flop.Phoenix.build_path(@path, Flop.set_page(@meta.flop, @meta.current_page + 1))}

          class={[

            "join-item btn btn-sm",

            @meta.current_page == @meta.total_pages && "btn-disabled"

          ]}

        >

          »

        </.link>

      </div>

    </div>

    """

  end

  defp build_page_links(meta, max_pages) do

    current = meta.current_page

    total = meta.total_pages

    range =

      if total <= max_pages do

        Enum.to_list(1..total)

      else

        half = div(max_pages, 2)

        start = max(1, min(current - half, total - max_pages + 1))

        stop = min(total, start + max_pages - 1)

        Enum.to_list(start..stop)

      end

    range

    |> maybe_add_ellipsis(:left, total)

    |> maybe_add_ellipsis(:right, total)

    |> Enum.map(fn

      :ellipsis -> {0, :ellipsis}

      page when page == current -> {page, :current}

      page -> {page, :page}

    end)

  end

  defp maybe_add_ellipsis([first | _] = pages, :left, _total) when first > 2,

    do: [1, :ellipsis | pages]

  defp maybe_add_ellipsis([first | _] = pages, :left, _total) when first == 2,

    do: [1 | pages]

  defp maybe_add_ellipsis(pages, :left, _total), do: pages

  defp maybe_add_ellipsis(pages, :right, total) do

    last = List.last(pages)

    cond do

      last < total - 1 -> pages ++ [:ellipsis, total]

      last == total - 1 -> pages ++ [total]

      true -> pages

    end

  end

  @doc """

  Formats a boolean for display. Returns "Yes", "No", or "-" for nil.

  """

  def format_boolean(nil), do: "-"

  def format_boolean(true), do: "Yes"

  def format_boolean(false), do: "No"

  @doc """

  Formats a date for display.

  ## Examples

      format_date(~U[2025-01-15 12:00:00Z])

      #=> "January 15, 2025"

  """

  def format_date(nil), do: "-"

  def format_date(datetime), do: Calendar.strftime(datetime, "%B %d, %Y")

  @doc """

  Formats a datetime for display. Returns "-" for nil values.

  ## Examples

      format_datetime(~U[2025-01-15 12:30:00Z])

      #=> "January 15, 2025 at 12:30 PM"

  """

  def format_datetime(nil), do: "-"

  def format_datetime(datetime), do: Calendar.strftime(datetime, "%B %d, %Y at %I:%M %p")

  @doc """

  Renders a data list.

  ## Examples

      <.list>

        <:item title="Title">{@post.title}</:item>

        <:item title="Views">{@post.views}</:item>