show activities in header

broadcast from Oban job

enqueue email deilvery

add mail templates

Author: lastcanal

config/config.exs

@@ -33,7 +33,7 @@ config :algora, Oban,
     github_og_image: 5,
     notify_bounty: 1,
     activity_notifier: 1,
-    email_notfier: 1
+    activity_mailer: 1
   ]
 
 # Configures the mailer

lib/algora/activities/activities.ex

@@ -5,6 +5,8 @@ defmodule Algora.Activities do
   alias Algora.Accounts.Identity
   alias Algora.Accounts.User
   alias Algora.Activities.Activity
+  alias Algora.Activities.Router
+  alias Algora.Activities.Views
   alias Algora.Bounties.Bounty
   alias Algora.Repo
 
@@ -199,48 +201,130 @@ defmodule Algora.Activities do
           assoc_id: a.assoc_id,
           assoc_name: ^table,
           assoc: t,
-          inserted_at: a.inserted_at
+          notify_users: a.notify_users,
+          visibility: a.visibility,
+          template: a.template,
+          meta: a.meta,
+          changes: a.changes,
+          trace_id: a.trace_id,
+          previous_event_id: a.previous_event_id,
+          inserted_at: a.inserted_at,
+          updated_at: a.updated_at
         }
 
+    struct(Activity, Algora.Repo.one(query))
+  end
+
+  def get_with_preloaded_assoc(table, id) do
+    schema = schema_from_table(table)
+
+    with %{assoc_id: assoc_id} = activity <- get(table, id),
+         assoc when is_map(assoc) <- get_preloaded_assoc(schema, assoc_id) do
+      Map.put(activity, :assoc, assoc)
+    end
+  end
+
+  def get_preloaded_assoc(schema, assoc_id) do
+    query =
+      if Kernel.function_exported?(schema, :query, 1) do
+        schema.query(assoc_id)
+      else
+        from a in schema, where: a.id == ^assoc_id
+      end
+
     Algora.Repo.one(query)
   end
 
-  def get_assoc(prefix, assoc_id) when prefix in ["bounty_activities"] do
-    get_assoc(prefix, assoc_id, [:owner])
+  def assoc_url(table, id) do
+    table |> get(id) |> Router.route()
   end
 
-  def get_assoc(prefix, assoc_id) when prefix in ["identity_activities"] do
-    get_assoc(prefix, assoc_id, [:user])
+  def subscribe do
+    Phoenix.PubSub.subscribe(Algora.PubSub, "activities")
   end
 
-  def get_assoc(prefix, assoc_id, preload) do
-    assoc_table = schema_from_table(prefix)
+  def subscribe(schema) when is_atom(schema) do
+    schema |> schema_from_table() |> subscribe()
+  end
 
-    query =
-      from a in assoc_table,
-        preload: ^preload,
-        where: a.id == ^assoc_id
+  def subscribe_table(table) when is_binary(table) do
+    Phoenix.PubSub.subscribe(Algora.PubSub, "activity:table:#{table}")
+  end
 
-    Algora.Repo.one(query)
+  def subscribe_user(user_id) when is_binary(user_id) do
+    Phoenix.PubSub.subscribe(Algora.PubSub, "activity:users:#{user_id}")
   end
 
-  def get_with_assoc(table, id) do
-    with %{assoc_id: assoc_id} = activity <- get(table, id),
-         assoc when is_map(assoc) <- get_assoc(table, assoc_id) do
-      Map.put(activity, :assoc, assoc)
-    end
+  def broadcast(%{notify_users: []}), do: []
+
+  def broadcast(%{notify_users: user_ids} = activity) do
+    :ok = Phoenix.PubSub.broadcast(Algora.PubSub, "activities", activity)
+    :ok = Phoenix.PubSub.broadcast(Algora.PubSub, "activity:table:#{activity.assoc_name}", activity)
+
+    users_query =
+      from u in Algora.Accounts.User,
+        where: u.id in ^user_ids,
+        select: u
+
+    users_query
+    |> Algora.Repo.all()
+    |> Enum.reduce([], fn user, not_online ->
+      # TODO setup notification preferences
+      :ok = Phoenix.PubSub.broadcast(Algora.PubSub, "activity:users:#{user.id}", activity)
+      [user | not_online]
+    end)
   end
 
-  def assoc_url(table, id) do
-    activity = get_with_assoc(table, id)
-    build_url(activity)
+  def notify_users(_activity, []), do: :ok
+
+  def notify_users(activity, users_to_notify) do
+    title = activity_email_title(activity)
+    body = activity_email_body(activity)
+
+    users_to_notify
+    |> Enum.reduce([], fn
+      %{name: display_name, email: email, id: id}, acc ->
+        changeset =
+          Algora.Activities.SendEmail.changeset(%{
+            title: title,
+            body: body,
+            user_id: id,
+            activity_id: activity.id,
+            activity_type: activity.type,
+            activity_table: activity.assoc_name,
+            name: display_name,
+            email: email
+          })
+
+        [changeset | acc]
+
+      _user, acc ->
+        acc
+    end)
+    |> Oban.insert_all()
+  end
+
+  def activity_email_title(activity) do
+    apply(Views, :"#{activity.type}_title", [activity, activity.assoc])
   end
 
-  def build_url(%{assoc: %Bounty{owner: user}}), do: {:ok, "/org/#{user.handle}/bounties"}
-  def build_url(%{assoc: %Identity{user: %{type: :individual} = user}}), do: {:ok, "/@/#{user.handle}"}
-  def build_url(%{assoc: %Identity{user: %{type: :organization} = user}}), do: {:ok, "/org/#{user.handle}"}
+  def activity_email_body(activity) do
+    apply(Views, :"#{activity.type}_txt", [activity, activity.assoc])
+  end
+
+  def redirect_url_for_activity(activity) do
+    slug =
+      activity.assoc_name
+      |> to_string()
+      |> String.replace("_activities", "")
+
+    "/a/#{slug}/#{activity.id}"
+  end
 
-  def build_url(_activity) do
-    {:error, :not_found}
+  def activity_type_to_name(type) do
+    type
+    |> to_string()
+    |> String.split("_")
+    |> Enum.map_join(" ", &String.capitalize(&1))
   end
 end

lib/algora/activities/jobs/notifier.ex

@@ -19,16 +19,16 @@ defmodule Algora.Activities.Notifier do
   end
 
   @impl Oban.Worker
-  def perform(%Oban.Job{args: args} = job) do
+  def perform(%Oban.Job{args: args}) do
     case args do
       %{
         "activity_id" => activity_id,
-        "target_id" => target_id,
         "table_name" => table
-      } = args
+      }
       when is_binary(table) ->
-        _activity = Activities.get(table, activity_id)
-
+        activity = Activities.get_with_preloaded_assoc(table, activity_id)
+        users_to_notify = Activities.broadcast(activity)
+        Activities.notify_users(activity, users_to_notify)
         :ok
 
       _args ->

lib/algora/activities/jobs/send_email.ex

@@ -1,14 +1,14 @@
 defmodule Algora.Activities.SendEmail do
   @moduledoc false
   use Oban.Worker,
-    queue: :activities,
-    max_attempts: 3,
-    tags: ["mail", "activities"]
+    queue: :activity_mailer,
+    max_attempts: 1,
+    tags: ["email", "activities"]
 
   # unique: [period: 30]
 
-  def changeset(activity, target) do
-    new(%{activity_id: activity.id, target_id: target.id})
+  def changeset(attrs) do
+    new(attrs)
   end
 
   @impl Oban.Worker

lib/algora/activities/router.ex

@@ -0,0 +1,14 @@
+defmodule Algora.Activities.Router do
+  alias Algora.Accounts.Identity
+  alias Algora.Bounties.Bounty
+
+  def route(%{assoc: %Bounty{owner: user}}), do: {:ok, "/org/#{user.handle}/bounties"}
+
+  def route(%{assoc: %Identity{user: %{type: :individual} = user}}), do: {:ok, "/@/#{user.handle}"}
+
+  def route(%{assoc: %Identity{user: %{type: :organization} = user}}), do: {:ok, "/org/#{user.handle}"}
+
+  def route(_activity) do
+    {:error, :not_found}
+  end
+end

lib/algora/activities/schemas/activity.ex

@@ -9,10 +9,6 @@ defmodule Algora.Activities.Activity do
     contract_prepaid
     contract_created
     contract_renewed
-    transaction_status_change
-    transaction_created
-    transaction_failed
-    transaction_processed
     identity_created
     bounty_awarded
     bounty_posted
@@ -32,17 +28,30 @@ defmodule Algora.Activities.Activity do
     field :trace_id, :string
     field :notify_users, {:array, :string}, default: []
     field :assoc_name, :string, virtual: true
+    field :assoc, :map, virtual: true
 
     belongs_to :user, Algora.Accounts.User
     belongs_to :previous_event, __MODULE__
 
     timestamps()
   end
 
+  def types, do: @activity_types
+
   @doc false
   def changeset(activity, attrs) do
     activity
-    |> cast(attrs, [:type, :visibility, :template, :meta, :changes, :trace_id, :user_id, :previous_event_id])
+    |> cast(attrs, [
+      :type,
+      :visibility,
+      :template,
+      :meta,
+      :changes,
+      :trace_id,
+      :user_id,
+      :previous_event_id,
+      :notify_users
+    ])
     |> validate_required([:type])
     |> foreign_key_constraint(:assoc_id)
     |> foreign_key_constraint(:user_id)

lib/algora/activities/views.ex

@@ -0,0 +1,15 @@
+defmodule Algora.Activities.Views do
+  @moduledoc false
+  alias Algora.Activities.Activity
+
+  require Algora.Activities.Activity
+  require EEx
+
+  @base_path Path.join([File.cwd!(), "lib", "algora", "activities", "views"])
+
+  Enum.each(Activity.types(), fn type ->
+    base_type = type |> to_string() |> String.split("_") |> List.first() |> String.to_atom()
+    EEx.function_from_file(:def, :"#{type}_txt", Path.join(@base_path, "#{type}.txt.eex"), [:activity, base_type])
+    EEx.function_from_file(:def, :"#{type}_title", Path.join(@base_path, "#{type}.title.eex"), [:activity, base_type])
+  end)
+end

lib/algora/activities/views/bounty_awarded.title.eex

@@ -0,0 +1 @@
+You have been rewarded a bounty on Algora!

lib/algora/activities/views/bounty_awarded.txt.eex

@@ -0,0 +1 @@
+<%= bounty.creator.display_name %> awarded you a Bounty for <% bounty.amount %>

lib/algora/activities/views/bounty_posted.title.eex

@@ -0,0 +1 @@
+New bounty posted to Algora