fix: update mailing schemas

fix: improve mailing with localized langs

fix: work in progress

fix: update views to use forms

fix: make imrpovements

fix: credo

fix: make progress and have a working worker

fix: make improvements

Author: spaenleh

config/config.exs

@@ -16,7 +16,7 @@ config :admin, Oban,
   ],
   engine: Oban.Engines.Basic,
   notifier: Oban.Notifiers.Postgres,
-  queues: [default: 10, mailers: 1],
+  queues: [default: 10, mailing: 2],
   repo: Admin.Repo
 
 config :admin, :scopes,

lib/admin/accounts.ex

@@ -179,6 +179,16 @@ defmodule Admin.Accounts do
     |> update_user_and_delete_all_tokens()
   end
 
+  def change_user_name(user, attrs \\ %{}) do
+    User.name_changeset(user, attrs)
+  end
+
+  def update_user_name(user, attrs \\ %{}) do
+    user
+    |> User.name_changeset(attrs)
+    |> Repo.update()
+  end
+
   ## Session
 
   @doc """
@@ -369,13 +379,23 @@ defmodule Admin.Accounts do
   def get_active_members do
     Repo.all(
       from(m in Account,
+        select: %{name: m.name, email: m.email, lang: fragment("?->>?", m.extra, "lang")},
         where:
           not is_nil(m.last_authenticated_at) and m.last_authenticated_at > ago(90, "day") and
             m.type == "individual"
       )
     )
   end
 
+  def get_members_by_language(language) do
+    Repo.all(
+      from(m in Account,
+        select: %{name: m.name, email: m.email, lang: fragment("?->>?", m.extra, "lang")},
+        where: fragment("?->>? = ?", m.extra, "lang", ^language) and m.type == "individual"
+      )
+    )
+  end
+
   def create_member(attrs \\ %{}) do
     %Account{}
     |> Account.changeset(attrs)

lib/admin/accounts/account.ex

@@ -9,6 +9,7 @@ defmodule Admin.Accounts.Account do
     field :name, :string
     field :email, :string
     field :type, :string
+    field :extra, :map
 
     timestamps(type: :utc_datetime)
   end

lib/admin/accounts/scope.ex

@@ -20,6 +20,8 @@ defmodule Admin.Accounts.Scope do
 
   defstruct user: nil
 
+  @type t :: %__MODULE__{user: User.t() | nil}
+
   @doc """
   Creates a scope for the given user.
 

lib/admin/accounts/user.ex

@@ -10,6 +10,8 @@ defmodule Admin.Accounts.User do
   # when we unify the access control for all users and use user roles to define who is an admin or not.
   schema "admins" do
     field :email, :string
+    field :name, :string
+    field :language, :string
     field :password, :string, virtual: true, redact: true
     field :hashed_password, :string, redact: true
     field :confirmed_at, :utc_datetime
@@ -138,4 +140,16 @@ defmodule Admin.Accounts.User do
     Bcrypt.no_user_verify()
     false
   end
+
+  def name_changeset(user, attrs) do
+    user
+    |> cast(attrs, [:name])
+    |> validate_required([:name])
+  end
+
+  def language_changeset(user, attrs) do
+    user
+    |> cast(attrs, [:language])
+    |> validate_required([:language])
+  end
 end

lib/admin/accounts/user_notifier.ex

@@ -69,6 +69,36 @@ defmodule Admin.Accounts.UserNotifier do
     )
   end
 
+  def deliver_call_to_action(user, subject, message_text, button_text, button_url) do
+    html_body =
+      EmailTemplates.render("call_to_action", %{
+        name: user.name,
+        message: message_text,
+        button_text: button_text,
+        button_url: button_url
+      })
+
+    deliver(
+      user.email,
+      subject,
+      html_body,
+      """
+
+      ==============================
+
+      Hi #{user.name},
+
+      #{message_text}
+
+      #{button_text} #{button_url}
+
+      ==============================
+      #{@footer}
+      """,
+      reply_to: @support_email
+    )
+  end
+
   @doc """
   Deliver publication removal information.
   """

lib/admin/languages.ex

@@ -0,0 +1,57 @@
+defmodule Admin.Languages do
+  @moduledoc """
+  This module handles the currently supported languages.
+
+  It allows to get a language list suitable for displaying a select input with some options disabled.
+  """
+  @languages [
+    %{value: "en", key: "English"},
+    %{value: "fr", key: "French"},
+    %{value: "es", key: "Spanish"},
+    %{value: "de", key: "German"},
+    %{value: "it", key: "Italian"}
+  ]
+
+  def all do
+    @languages
+  end
+
+  def all_options do
+    @languages |> Enum.map(&Keyword.new(&1))
+  end
+
+  def all_values do
+    @languages |> Enum.map(& &1.value)
+  end
+
+  @doc """
+  Returns a list of languages excluding the ones with the given codes.
+
+  ## Examples
+    iex> Admin.Languages.excluding(["en", "fr"])
+    [%{value: "es", key: "Spanish"}, %{value: "de", key: "German"}, %{value: "it", key: "Italian"}]
+  """
+  def excluding(language_codes) when is_list(language_codes) do
+    @languages |> Enum.reject(&(&1.value in language_codes))
+  end
+
+  @doc """
+  Returns a list of keyword lists with languages with the disabled languages. Can be used in select options.
+
+  ## Examples
+    iex> Admin.Languages.disabling(["en", "fr"])
+    [
+      [value: "en", key: "English", disabled: true],
+      [value: "fr", key: "French", disabled: true],
+      [value: "es", key: "Spanish", disabled: false],
+      [value: "de", key: "German", disabled: false],
+      [value: "it", key: "Italian", disabled: false]
+    ]
+  """
+  def disabling(language_codes) when is_list(language_codes) do
+    @languages
+    |> Enum.map(fn %{value: value, key: key} ->
+      Keyword.new(value: value, key: key, disabled: value in language_codes)
+    end)
+  end
+end

lib/admin/mailer_worker.ex

@@ -0,0 +1,115 @@
+defmodule Admin.MailingWorker do
+  @moduledoc """
+  Worker for sending batch emails to a target audience with internationalisation.
+  """
+
+  use Oban.Worker, queue: :mailing
+
+  alias Admin.Accounts
+  alias Admin.Accounts.Scope
+  alias Admin.Accounts.UserNotifier
+  alias Admin.Notifications
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{
+        args:
+          %{
+            "user_id" => user_id,
+            "notification_id" => notification_id
+          } =
+            _args
+      }) do
+    user = Accounts.get_user!(user_id)
+    scope = Scope.for_user(user)
+
+    with {:ok, notification} <- Notifications.get_notification(scope, notification_id),
+         included_langs = notification.localized_emails |> Enum.map(& &1.language),
+         {:ok, audience} <-
+           Notifications.get_target_audience(
+             scope,
+             notification.audience,
+             if(notification.use_strict_languages, do: [only_langs: included_langs], else: [])
+           ) do
+      # save number of recipients to the notification
+      Notifications.update_recipients(notification, %{total_recipients: length(audience)})
+      # start sending emails
+      send_emails(scope, notification, audience)
+      # await email progress messages
+      await_emails(scope, notification)
+    else
+      {:error, :notification_not_found} ->
+        {:cancel, :notification_not_found}
+
+      {:error, error} ->
+        {:error, "Failed to send notification: #{inspect(error)}"}
+    end
+  end
+
+  defp send_emails(scope, notification, audience) do
+    job_pid = self()
+
+    Task.async(fn ->
+      audience
+      |> Enum.with_index(1)
+      |> Enum.each(fn {user, index} ->
+        send_local_email(scope, user, notification)
+
+        current_progress = trunc(index / length(audience) * 100)
+
+        send(job_pid, {:progress, current_progress})
+
+        :timer.sleep(1000)
+      end)
+
+      send(job_pid, {:completed})
+    end)
+  end
+
+  defp send_local_email(scope, user, notification) do
+    # get the localized email
+    case Notifications.get_local_email_from_notification(notification, user.lang) do
+      nil ->
+        :skipped
+
+      localized_email ->
+        # deliver the email
+        UserNotifier.deliver_call_to_action(
+          user,
+          localized_email.subject,
+          localized_email.message,
+          localized_email.button_text,
+          localized_email.button_url
+        )
+
+        # save message log
+        Notifications.save_log(
+          scope,
+          %{
+            email: user.email,
+            status: "sent"
+          },
+          notification
+        )
+
+        :ok
+    end
+  end
+
+  defp await_emails(scope, notification) do
+    receive do
+      {:progress, percent} ->
+        Notifications.report_sending_progress(scope, {:progress, notification.name, percent})
+        await_emails(scope, notification)
+
+      {:completed} ->
+        Notifications.report_sending_progress(scope, {:completed, notification.name})
+
+      {:failed} ->
+        Notifications.report_sending_progress(scope, {:failed, notification.name})
+    after
+      30_000 ->
+        Notifications.report_sending_progress(scope, {:failed, notification.name})
+        raise RuntimeError, "no progress after 30s"
+    end
+  end
+end