feat: handle dynamic inline image attachments in email campaign preview and delivery

Author: zcesur

lib/algora/activities/jobs/send_campaign_email.ex

@@ -9,33 +9,50 @@ defmodule Algora.Activities.Jobs.SendCampaignEmail do
   alias AlgoraWeb.Admin.CampaignLive
 
   @impl Oban.Worker
-  def perform(%Oban.Job{
-        args: %{
-          "id" => _id,
-          "recipient_email" => _recipient_email,
-          "subject" => subject,
-          "recipient" => encoded_recipient,
-          "template_params" => encoded_template_params,
-          "from_name" => from_name,
-          "from_email" => from_email,
-          "preheader" => preheader
-        }
-      }) do
-    recipient = Algora.Util.base64_to_term!(encoded_recipient)
-    template_params = Algora.Util.base64_to_term!(encoded_template_params)
+  def perform(%Oban.Job{args: %{"recipient" => encoded_recipient} = args}) do
+    args
+    |> Map.put("recipient", Algora.Util.base64_to_term!(encoded_recipient))
+    |> deliver_email()
+  end
+
+  defp deliver_email(%{
+         "subject" => subject,
+         "recipient" => %{"repo_owner" => repo_owner, "repo_name" => repo_name} = recipient,
+         "template" => template,
+         "from_name" => from_name,
+         "from_email" => from_email,
+         "preheader" => preheader
+       }) do
     token = Algora.Admin.token!()
 
-    with {:ok, repo} <- Workspace.ensure_repository(token, recipient["repo_owner"], recipient["repo_name"]),
-         {:ok, _owner} <- Workspace.ensure_user(token, recipient["repo_owner"]),
+    with {:ok, repo} <- Workspace.ensure_repository(token, repo_owner, repo_name),
+         {:ok, _owner} <- Workspace.ensure_user(token, repo_owner),
          {:ok, _contributors} <- Workspace.ensure_contributors(token, repo),
          {:ok, _languages} <- Workspace.ensure_repo_tech_stack(token, repo) do
       CampaignLive.deliver_email(
         recipient: recipient,
         subject: subject,
-        template_params: template_params,
+        template: template,
         from: {from_name, from_email},
         preheader: preheader
       )
     end
   end
+
+  defp deliver_email(%{
+         "subject" => subject,
+         "recipient" => recipient,
+         "template" => template,
+         "from_name" => from_name,
+         "from_email" => from_email,
+         "preheader" => preheader
+       }) do
+    CampaignLive.deliver_email(
+      recipient: recipient,
+      subject: subject,
+      template: template,
+      from: {from_name, from_email},
+      preheader: preheader
+    )
+  end
 end

lib/algora_web/live/admin/campaign_live.ex

@@ -7,6 +7,7 @@ defmodule AlgoraWeb.Admin.CampaignLive do
   import Ecto.Query
 
   alias Algora.Activities.Jobs.SendCampaignEmail
+  alias Algora.Admin
   alias Algora.Mailer
   alias Algora.Repo
   alias Algora.Workspace.Repository
@@ -302,20 +303,12 @@ defmodule AlgoraWeb.Admin.CampaignLive do
     Repo.transact(fn _ ->
       recipients
       |> Enum.map(fn recipient ->
-        template_params = [
-          markdown: render_preview(template, recipient),
-          cta: %{
-            href: "#{AlgoraWeb.Endpoint.url()}/go/#{recipient["repo_owner"]}/#{recipient["repo_name"]}",
-            src: "cid:#{recipient["repo_owner"]}.png"
-          }
-        ]
-
         %{
           id: "2025-04-oss",
           subject: subject,
           recipient_email: recipient["email"],
           recipient: Algora.Util.term_to_base64(recipient),
-          template_params: Algora.Util.term_to_base64(template_params),
+          template: template,
           from_name: from_name,
           from_email: from_email,
           preheader: render_preview(preheader, recipient)
@@ -332,38 +325,44 @@ defmodule AlgoraWeb.Admin.CampaignLive do
   end
 
   def deliver_email(opts) do
-    recipient = opts[:recipient]
-
-    case :get
-         |> Finch.build("https://algora.io/og/go/#{recipient["repo_owner"]}/#{recipient["repo_name"]}")
-         |> Finch.request(Algora.Finch) do
-      {:ok, %Finch.Response{status: status, body: body}} when status in 200..299 ->
-        opts
-        |> Keyword.put(:attachments, [
-          Swoosh.Attachment.new({:data, body},
-            filename: "#{recipient["repo_owner"]}.png",
-            content_type: "image/png",
-            type: :inline
-          )
-        ])
-        |> deliver()
+    case opts[:template] |> render_preview(opts[:recipient]) |> extract_attachments() do
+      {:ok, {preview, attachments}} ->
+        Email.new()
+        |> Email.to(opts[:recipient]["email"])
+        |> Email.from(opts[:from])
+        |> Email.subject(opts[:subject])
+        |> Email.text_body(Mailer.text_template(markdown: preview))
+        |> Email.html_body(Mailer.html_template([markdown: preview], preheader: opts[:preheader]))
+        |> then(&Enum.reduce(attachments, &1, fn attachment, acc -> Email.attachment(acc, attachment) end))
+        |> Mailer.deliver_with_logging()
 
       {:error, reason} ->
-        raise reason
+        Admin.alert("Failed to deliver email: #{inspect(reason)}")
+        {:error, reason}
     end
   end
 
-  defp deliver(opts) do
-    email =
-      Email.new()
-      |> Email.to(opts[:recipient]["email"])
-      |> Email.from(opts[:from])
-      |> Email.subject(opts[:subject])
-      |> Email.text_body(Mailer.text_template(opts[:template_params]))
-      |> Email.html_body(Mailer.html_template(opts[:template_params], preheader: opts[:preheader]))
+  defp extract_attachments(preview) do
+    image_regex = ~r/!\[(.*?)\]\((.*?)\)/
+
+    image_regex
+    |> Regex.scan(preview)
+    |> Enum.reduce_while({:ok, {preview, []}}, fn [full_match, alt, src], {:ok, {current_preview, current_attachments}} ->
+      case :get |> Finch.build(src) |> Finch.request(Algora.Finch) do
+        {:ok, %Finch.Response{status: status, body: body}} when status in 200..299 ->
+          attachment =
+            Swoosh.Attachment.new({:data, body}, filename: "#{alt}.png", content_type: "image/png", type: :inline)
 
-    email = Enum.reduce(opts[:attachments], email, fn attachment, acc -> Email.attachment(acc, attachment) end)
+          new_preview = String.replace(current_preview, full_match, "![#{alt}](cid:#{alt}.png)")
+          {:cont, {:ok, {new_preview, [attachment | current_attachments]}}}
 
-    Mailer.deliver_with_logging(email)
+        {:error, reason} ->
+          {:halt, {:error, reason}}
+      end
+    end)
+    |> case do
+      {:ok, {preview, attachments}} -> {:ok, {preview, Enum.reverse(attachments)}}
+      {:error, reason} -> {:error, reason}
+    end
   end
 end