# Who emails come from.

config :my_app, MyApp.Emails,

  from:

    {System.get_env("EMAIL_FROM_NAME", "MyApp"),

     System.get_env("EMAIL_FROM_ADDRESS", "contact@example.com")}

  @moduledoc """

  The account emails from `phx.gen.auth`, sent as templates from

  `MyApp.Emails.Templates`.

  """

  alias MyApp.Emails

  alias MyApp.Emails.Templates

    Emails.deliver(Templates.ChangeEmail, user, %{url: url})

      %User{confirmed_at: nil} -> Emails.deliver(Templates.ConfirmAccount, user, %{url: url})

      _ -> Emails.deliver(Templates.LoginLink, user, %{url: url})

defmodule MyApp.Emails do

  @moduledoc """

  Renders and sends emails defined in code (`MyApp.Emails.Template`).

  Templates are modules, so what goes out to users is reviewed and versioned

  like any other change. The sender comes from config:

      config :my_app, MyApp.Emails, from: {"MyApp", "contact@example.com"}

  """

  import Swoosh.Email

  alias MyApp.Mailer

  @doc """

  Sends a template to a user. `assigns` are passed to the template next to

  `:user`. Returns `{:ok, email}`.

  ## Examples

      deliver(MyApp.Emails.Templates.LoginLink, user, %{url: url})

  """

  def deliver(template, user, assigns \\ %{}) do

    email = build(template, user, assigns)

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

      {:ok, email}

    end

  end

  @doc """

  Builds the Swoosh email for a template without sending it.

  """

  def build(template, user, assigns \\ %{}) do

    rendered = render(template, Map.put(assigns, :user, user))

    new()

    |> to(user.email)

    |> from(from_address())

    |> subject(rendered.subject)

    |> html_body(rendered.html)

    |> text_body(rendered.text)

  end

  @doc """

  Renders a template to `%{subject, preheader, html, text}`.

  """

  def render(template, assigns) do

    %{

      subject: template.subject(assigns),

      preheader: template.preheader(assigns),

      html: assigns |> template.html() |> Phoenix.HTML.Safe.to_iodata() |> IO.iodata_to_binary(),

      text: template.text(assigns)

    }

  end

  @doc """

  Renders a template with its sample assigns and a sample recipient, for

  previews.

  """

  def render_sample(template, email \\ "recipient@example.com") do

    render(template, Map.put(template.sample_assigns(), :user, sample_user(email)))

  end

  @doc """

  Sends a template with its sample assigns to any address, with "[Test]" in

  the subject. For checking a template from the admin panel.

  """

  def deliver_test(template, email) do

    test_email = build(template, sample_user(email), template.sample_assigns())

    test_email

    |> subject("[Test] " <> test_email.subject)

    |> Mailer.deliver()

  end

  defp sample_user(email), do: %{id: Ecto.UUID.generate(), email: email}

  def from_address do

    :my_app

    |> Application.get_env(__MODULE__, [])

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

  end

end

defmodule MyApp.Emails.Layout do

  @moduledoc """

  Shared chrome for emails. Styles are inline, since many email clients

  ignore `<style>` tags.

  """

  use Phoenix.Component

  @doc """

  Wraps an email's content. Pass `unsubscribe_url` for marketing email, and

  the footer links to it; transactional email has no unsubscribe link.

  """

  attr :unsubscribe_url, :string, default: nil

  attr :preheader, :string, default: nil

  slot :inner_block, required: true

  def layout(assigns) do

    ~H"""

    <!DOCTYPE html>

    <html>

      <head>

        <meta charset="utf-8" />

        <meta name="viewport" content="width=device-width, initial-scale=1" />

      </head>

      <body style="margin: 0; padding: 0; background-color: #f4f4f5;">

        <div

          :if={@preheader}

          style="display: none; max-height: 0; overflow: hidden; opacity: 0;"

        >

          {@preheader}

        </div>

        <table role="presentation" width="100%" cellpadding="0" cellspacing="0">

          <tr>

            <td align="center" style="padding: 32px 16px;">

              <table

                role="presentation"

                width="100%"

                cellpadding="0"

                cellspacing="0"

                style="max-width: 560px; background-color: #ffffff; border-radius: 8px;"

              >

                <tr>

                  <td style="padding: 32px; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif; font-size: 16px; line-height: 1.6; color: #18181b;">

                    {render_slot(@inner_block)}

                  </td>

                </tr>

              </table>

              <p

                :if={@unsubscribe_url}

                style="margin: 16px 0 0; font-family: Helvetica, Arial, sans-serif; font-size: 12px; color: #71717a;"

              >

                You're getting this because you have an account.

                <a href={@unsubscribe_url} style="color: #71717a;">Unsubscribe</a>

              </p>

            </td>

          </tr>

        </table>

      </body>

    </html>

    """

  end

  slot :inner_block, required: true

  def heading(assigns) do

    ~H"""

    <h1 style="margin: 0 0 16px; font-size: 22px; line-height: 1.3;">

      {render_slot(@inner_block)}

    </h1>

    """

  end

  slot :inner_block, required: true

  def paragraph(assigns) do

    ~H"""

    <p style="margin: 0 0 16px;">{render_slot(@inner_block)}</p>

    """

  end

  attr :href, :string, required: true

  slot :inner_block, required: true

  def button(assigns) do

    ~H"""

    <p style="margin: 24px 0;">

      <a

        href={@href}

        style="display: inline-block; padding: 12px 20px; background-color: #4f46e5; color: #ffffff; text-decoration: none; border-radius: 6px; font-weight: 600;"

      >

        {render_slot(@inner_block)}

      </a>

    </p>

    """

  end

  @doc "Small print, like why someone got the email."

  slot :inner_block, required: true

  def fine_print(assigns) do

    ~H"""

    <p style="margin: 24px 0 0; font-size: 13px; color: #71717a;">{render_slot(@inner_block)}</p>

    """

  end

end

defmodule MyApp.Emails.Template do

  @moduledoc """

  An email defined in code: a subject, an optional preheader, an HTML body,

  and a plain-text body.

  Every template gets `:user` (needing at least `:email`) plus whatever its

  sender passes, like a login URL. `sample_assigns/0` supplies stand-ins for

  those, so the admin panel can preview the email.

  `use MyApp.Emails.Template` imports `MyApp.Emails.Layout` for the shared

  chrome.

  ## Example

      defmodule MyApp.Emails.Templates.Receipt do

        use MyApp.Emails.Template

        @impl true

        def name, do: "Receipt"

        @impl true

        def subject(_assigns), do: "Your receipt"

        @impl true

        def html(assigns) do

          ~H\"\"\"

          <.layout>

            <.paragraph>Thanks for your order, {@user.email}.</.paragraph>

          </.layout>

          \"\"\"

        end

        @impl true

        def text(assigns), do: "Thanks for your order, \#{assigns.user.email}."

      end

  """

  @type assigns :: %{required(:user) => map(), optional(atom()) => term()}

  @doc "A short label for the admin panel."

  @callback name() :: String.t()

  @doc "What the email is for, shown in the admin panel."

  @callback description() :: String.t()

  @callback subject(assigns) :: String.t()

  @doc "Preview text shown after the subject in most inboxes."

  @callback preheader(assigns) :: String.t() | nil

  @callback html(assigns) :: Phoenix.LiveView.Rendered.t()

  @doc "The plain-text version, which spam filters expect alongside HTML."

  @callback text(assigns) :: String.t()

  @doc "Stand-in assigns, besides `:user`, for previews and test sends."

  @callback sample_assigns() :: map()

  defmacro __using__(_opts) do

    quote do

      @behaviour MyApp.Emails.Template

      use Phoenix.Component

      import MyApp.Emails.Layout

      @impl true

      def description, do: ""

      @impl true

      def preheader(_assigns), do: nil

      @impl true

      def sample_assigns, do: %{}

      defoverridable description: 0, preheader: 1, sample_assigns: 0

    end

  end

end

defmodule MyApp.Emails.Templates do

  @moduledoc """

  The catalog of transactional email templates: the emails your app sends

  because of something a user did, like logging in. They always go out and

  have no unsubscribe link.

  Code sends them by module, through `MyApp.Emails.deliver/3`. The catalog's

  keys name them in the admin panel, where each one can be previewed and

  sent as a test.

  """

  alias MyApp.Emails.Templates

  @templates %{

    "login_link" => Templates.LoginLink,

    "confirm_account" => Templates.ConfirmAccount,

    "change_email" => Templates.ChangeEmail

  }

  @doc "Every template, as `{key, module}` sorted by name."

  def all, do: Enum.sort_by(@templates, fn {_key, module} -> module.name() end)

  @doc "The template module for a key, or nil."

  def get(key), do: Map.get(@templates, key)

end

defmodule MyApp.Emails.Templates.ChangeEmail do

  @moduledoc "Confirms a new email address from the user's settings."

  use MyApp.Emails.Template

  @impl true

  def name, do: "Change email"

  @impl true

  def description, do: "Sent to a new address when a user changes their email in settings."

  @impl true

  def subject(_assigns), do: "Confirm your new email"

  @impl true

  def sample_assigns,

    do: %{url: MyAppWeb.Endpoint.url() <> "/users/settings/confirm-email/sample-token"}

  @impl true

  def html(assigns) do

    ~H"""

    <.layout>

      <.heading>Confirm your new email</.heading>

      <.paragraph>Confirm {@user.email} as the address for your MyApp account.</.paragraph>

      <.button href={@url}>Confirm email</.button>

      <.fine_print>If you didn't request this change, you can ignore this email.</.fine_print>

    </.layout>

    """

  end

  @impl true

  def text(assigns) do

    """

    Hi #{assigns.user.email},

    You can change your email by visiting the URL below:

    #{assigns.url}

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

    """

  end

end

defmodule MyApp.Emails.Templates.ConfirmAccount do

  @moduledoc "The first login link, which also confirms a new account."

  use MyApp.Emails.Template

  @impl true

  def name, do: "Confirm account"

  @impl true

  def description, do: "Sent to a new user, whose first login confirms their account."

  @impl true

  def subject(_assigns), do: "Confirm your MyApp account"

  @impl true

  def preheader(_assigns), do: "One click and you're in."

  @impl true

  def sample_assigns, do: %{url: MyAppWeb.Endpoint.url() <> "/users/log-in/sample-token"}

  @impl true

  def html(assigns) do

    ~H"""

    <.layout preheader={preheader(assigns)}>

      <.heading>Confirm your account</.heading>

      <.paragraph>Welcome! Confirm {@user.email} to finish creating your account.</.paragraph>

      <.button href={@url}>Confirm account</.button>

      <.fine_print>If you didn't create an account with us, you can ignore this email.</.fine_print>

    </.layout>

    """

  end

  @impl true

  def text(assigns) do

    """

    Hi #{assigns.user.email},

    You can confirm your account by visiting the URL below:

    #{assigns.url}

    If you didn't create an account with us, please ignore this.

    """

  end

end

defmodule MyApp.Emails.Templates.LoginLink do

  @moduledoc "The magic link a confirmed user signs in with."

  use MyApp.Emails.Template

  @impl true

  def name, do: "Login link"

  @impl true

  def description, do: "Sent when a confirmed user asks to log in by email."

  @impl true

  def subject(_assigns), do: "Log in to MyApp"

  @impl true

  def preheader(_assigns), do: "Your login link is inside."

  @impl true

  def sample_assigns, do: %{url: MyAppWeb.Endpoint.url() <> "/users/log-in/sample-token"}

  @impl true

  def html(assigns) do

    ~H"""

    <.layout preheader={preheader(assigns)}>

      <.heading>Log in to MyApp</.heading>

      <.paragraph>Hi {@user.email}, use the button below to log in.</.paragraph>

      <.button href={@url}>Log in</.button>

      <.fine_print>If you didn't request this email, you can ignore it.</.fine_print>

    </.layout>

    """

  end

  @impl true

  def text(assigns) do

    """

    Hi #{assigns.user.email},

    You can log into your account by visiting the URL below:

    #{assigns.url}

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

    """

  end

end

defmodule MyAppAdminWeb.EmailComponents do

  @moduledoc """

  Components shared by the admin email pages.

  """

  use MyAppAdminWeb, :html

  @doc """

  Renders a template's subject, preheader, and HTML and text bodies.

  The HTML goes in a sandboxed iframe, so the email's styles stay isolated.

  """

  attr :rendered, :map, required: true, doc: "from `MyApp.Emails.render/2`"

  def template_preview(assigns) do

    ~H"""

    <.list>

      <:item title="Subject">{@rendered.subject}</:item>

      <:item :if={@rendered.preheader} title="Preheader">{@rendered.preheader}</:item>

    </.list>

    <div class="tabs tabs-border mt-6">

      <input type="radio" name="preview" class="tab" aria-label="HTML" checked />

      <div class="tab-content pt-4">

        <iframe

          id="html-preview"

          srcdoc={@rendered.html}

          sandbox=""

          class="w-full h-[36rem] rounded-box border border-base-content/10 bg-white"

        />

      </div>

      <input type="radio" name="preview" class="tab" aria-label="Text" />

      <div class="tab-content pt-4">

        <pre

          id="text-preview"

          class="whitespace-pre-wrap text-sm p-4 rounded-box border border-base-content/10"

        >{@rendered.text}</pre>

      </div>

    </div>

    """

  end

  @doc """

  Renders a form for sending a template as a test.

  """

  attr :form, Phoenix.HTML.Form, required: true

  def test_send_form(assigns) do

    ~H"""

    <.form for={@form} id="test-form" phx-submit="send_test" class="flex items-end gap-2 my-6">

      <div class="grow">

        <.input field={@form[:email]} type="email" label="Send a test to" required />

      </div>

      <div class="mb-2"><.button variant="primary">Send test</.button></div>

    </.form>

    """

  end

  def test_form(admin_scope), do: to_form(%{"email" => admin_scope.admin_user.email}, as: :test)

end

      <:section title="Emails">

        <.sidebar_item

          icon="hero-envelope-mini"

          navigate={~p"/admin/emails"}

          current={@page_selected == :email_templates}

        >

          Templates

        </.sidebar_item>

      </:section>

defmodule MyAppAdminWeb.EmailTemplateLive.Index do

  use MyAppAdminWeb, :live_view

  alias MyApp.Emails.Templates

  def render(assigns) do

    ~H"""

    <Layouts.admin_ui flash={@flash} current_scope={@current_scope} page_selected={:email_templates}>

      <.header>

        Email templates

        <:subtitle>

          Defined in code. Transactional emails always send and have no unsubscribe link.

        </:subtitle>

      </.header>

      <.table

        id="transactional-templates"

        rows={@templates}

        row_click={fn {key, _module} -> JS.navigate(~p"/admin/emails/#{key}") end}

      >

        <:col :let={{_key, module}} label="Name">{module.name()}</:col>

        <:col :let={{key, _module}} label="Key"><code>{key}</code></:col>

        <:col :let={{_key, module}} label="Description">{module.description()}</:col>

      </.table>

    </Layouts.admin_ui>

    """

  end

  def mount(_params, _session, socket) do

    {:ok, assign(socket, templates: Templates.all())}

  end

end

defmodule MyAppAdminWeb.EmailTemplateLive.Show do

  use MyAppAdminWeb, :live_view

  import MyAppAdminWeb.EmailComponents

  alias MyApp.Emails

  alias MyApp.Emails.Templates

  def render(assigns) do

    ~H"""

    <Layouts.admin_ui flash={@flash} current_scope={@current_scope} page_selected={:email_templates}>

      <.header>

        {@template.name()}

        <:subtitle>{@template.description()}</:subtitle>

        <:actions>

          <.link navigate={~p"/admin/emails"}>

            <.button>Back</.button>

          </.link>

        </:actions>

      </.header>

      <.list>

        <:item title="Module"><code>{inspect(@template)}</code></:item>

      </.list>

      <.test_send_form form={@test_form} />

      <.template_preview rendered={@rendered} />

    </Layouts.admin_ui>

    """

  end

  def mount(%{"key" => key}, _session, socket) do

    case Templates.get(key) do

      nil ->

        {:ok,

         socket

         |> put_flash(:error, "There's no email template #{key}.")

         |> push_navigate(to: ~p"/admin/emails")}

      template ->

        {:ok,

         assign(socket,

           template: template,

           rendered: Emails.render_sample(template),

           test_form: test_form(socket.assigns.current_scope)

         )}

    end

  end

  def handle_event("send_test", %{"test" => %{"email" => email}}, socket) do

    case Emails.deliver_test(socket.assigns.template, email) do

      {:ok, _} ->

        {:noreply, put_flash(socket, :info, "Test sent to #{email}.")}

      {:error, _reason} ->

        {:noreply, put_flash(socket, :error, "The test email couldn't be sent.")}

    end

  end

end

      live "/emails", EmailTemplateLive.Index

      live "/emails/:key", EmailTemplateLive.Show

defmodule MyApp.EmailsTest do

  use MyApp.DataCase, async: true

  import Swoosh.TestAssertions

  import MyApp.AccountsFixtures

  alias MyApp.Accounts

  alias MyApp.Emails

  alias MyApp.Emails.Templates

  test "every template renders a subject, HTML, and text from its samples" do

    for {_key, template} <- Templates.all() do

      rendered = Emails.render_sample(template)

      assert rendered.subject != ""

      assert rendered.html =~ "<html>"

      assert rendered.text =~ "recipient@example.com"

    end

  end

  test "deliver/3 sends HTML and text from the configured sender" do

    user = user_fixture()

    url = "https://example.com/log-in/abc"

    {:ok, email} = Emails.deliver(Templates.LoginLink, user, %{url: url})

    assert email.from == Emails.from_address()

    assert email.html_body =~ ~s(href="#{url}")

    assert email.text_body =~ url

  end

  test "account emails are templates" do

    user = unconfirmed_user_fixture()

    Accounts.deliver_login_instructions(user, &"https://example.com/#{&1}")

    assert_email_sent(subject: "Confirm your MyApp account")

    {:ok, user} =

      user |> Ecto.Changeset.change(confirmed_at: DateTime.utc_now(:second)) |> Repo.update()

    Accounts.deliver_login_instructions(user, &"https://example.com/#{&1}")

    assert_email_sent(subject: "Log in to MyApp")

  end

  test "test sends are marked as tests" do

    {:ok, _} = Emails.deliver_test(Templates.ChangeEmail, "me@example.com")

    assert_email_sent(to: "me@example.com", subject: "[Test] Confirm your new email")

  end

end

defmodule MyAppAdminWeb.EmailTemplateLiveTest do

  use MyAppWeb.ConnCase, async: true

  import Phoenix.LiveViewTest

  import Swoosh.TestAssertions

  alias MyAppAdmin.Accounts

  setup %{conn: conn} do

    admin = Accounts.get_or_create_admin_user_by_email!("admin@example.com")

    token = Accounts.generate_admin_user_session_token(admin)

    %{conn: init_test_session(conn, %{admin_user_token: token})}

  end

  test "requires an admin" do

    assert {:error, {:redirect, _}} = live(build_conn(), ~p"/admin/emails")

  end

  test "lists the templates in code", %{conn: conn} do

    {:ok, _lv, html} = live(conn, ~p"/admin/emails")

    assert html =~ "Login link"

    assert html =~ "Confirm account"

    assert html =~ "Change email"

  end

  test "previews a template and sends a test", %{conn: conn} do

    {:ok, lv, html} = live(conn, ~p"/admin/emails/login_link")

    assert html =~ "Log in to MyApp"

    assert has_element?(lv, "#html-preview")

    assert has_element?(lv, "#text-preview", "recipient@example.com")

    lv |> form("#test-form", test: %{email: "me@example.com"}) |> render_submit()

    assert_email_sent(to: "me@example.com", subject: "[Test] Log in to MyApp")

  end

  test "an unknown template goes back to the list", %{conn: conn} do

    assert {:error, {:live_redirect, %{to: "/admin/emails"}}} = live(conn, ~p"/admin/emails/nope")

  end

end