load association for activities

drop transaction activities and 'second' level activities associated
with a user

Author: lastcanal

lib/algora/activities/activities.ex

@@ -5,6 +5,7 @@ defmodule Algora.Activities do
   alias Algora.Accounts.User
   alias Algora.Activities.Activity
   alias Algora.Repo
+  alias Ecto.Multi
 
   @tables [
     :identity_activities,
@@ -43,9 +44,7 @@ defmodule Algora.Activities do
     :owned_installations,
     :connected_installations,
     :client_contracts,
-    {:client_contracts, :transactions},
     :client_contracts,
-    {:contractor_contracts, :transactions},
     :contractor_contracts
   ]
 
@@ -67,20 +66,19 @@ defmodule Algora.Activities do
   end
 
   def base_query(table_name) when is_binary(table_name) do
-    from(_e in {table_name, Activity})
+    assoc_name = schema_from_table(table_name)
+    base = from(e in {table_name, Activity})
+
+    from(u in subquery(base),
+      select_merge: %{
+        id: u.id,
+        type: u.type,
+        assoc_id: u.assoc_id,
+        assoc_name: ^table_name
+      }
+    )
   end
 
-  # def base_query({parent_table_name, table_name}) do
-  #   parent = to_string(parent_table_name)
-  #   child = to_string(table_name)
-
-  #   parent_table_name
-  #   |> base_query()
-  #   |> join(:inner, [p], assoc(p, ^parent), as: :parent)
-  #   |> join(:inner, [c], assoc(c, ^child), as: :child)
-  #   |> join(:inner, [a], assoc(a, :activities), as: :activities)
-  # end
-
   def base_query_for_user(user_id) do
     [head | tail] = @user_attributes
     first_query = base_query_for_user(user_id, head)
@@ -91,21 +89,22 @@ defmodule Algora.Activities do
     end)
   end
 
-  def base_query_for_user(user_id, {parent_table_name, table_name}) do
-    from u in User,
-      where: u.id == ^user_id,
-      join: p in assoc(u, ^parent_table_name),
-      join: c in assoc(p, ^table_name),
-      join: a in assoc(c, :activities),
-      select: a
-  end
-
-  def base_query_for_user(user_id, name) do
-    from u in User,
-      where: u.id == ^user_id,
-      join: c in assoc(u, ^name),
-      join: a in assoc(c, :activities),
-      select: a
+  def base_query_for_user(user_id, relation_name) do
+    table_name = table_from_user_relation(relation_name)
+    assoc_name = schema_from_table(table_name)
+
+    base =
+      from u in User,
+        where: u.id == ^user_id,
+        join: c in assoc(u, ^relation_name),
+        join: a in assoc(c, :activities),
+        select: %{
+          id: a.id,
+          type: a.type,
+          assoc_id: a.assoc_id,
+          assoc_name: ^table_name,
+          inserted_at: a.inserted_at
+        }
   end
 
   def all(table_name) when is_binary(table_name) do
@@ -126,20 +125,90 @@ defmodule Algora.Activities do
     base_query()
     |> order_by(fragment("inserted_at DESC"))
     |> limit(40)
-    |> Repo.all()
+    |> all_with_assoc()
   end
 
   def all_for_user(user_id) do
     user_id
     |> base_query_for_user()
     |> order_by(fragment("inserted_at DESC"))
     |> limit(40)
-    |> Repo.all()
+    |> all_with_assoc()
   end
 
   def insert(target, activity) do
     target
     |> Activity.build_activity(activity)
     |> Algora.Repo.insert()
   end
+
+  def all_with_assoc(query) do
+    multi =
+      Multi.new()
+      |> Multi.run(:activities, fn repo, _changes ->
+        {:ok, repo.all(query)}
+      end)
+      |> Multi.run(:associations, fn repo, %{activities: activities} ->
+        associations =
+          Enum.map(activities, fn activity ->
+            repo.one(from b in schema_from_table(activity.assoc_name), where: b.id == ^activity.assoc_id)
+          end)
+
+        {:ok, associations}
+      end)
+      |> Multi.run(:preloaded, fn _repo, %{activities: activities, associations: assocs} ->
+        preloaded =
+          Enum.zip_with(activities, assocs, fn act, assoc ->
+            Map.put(act, :assoc, assoc)
+          end)
+
+        {:ok, preloaded}
+      end)
+
+    case Repo.transaction(multi) do
+      {:ok, %{preloaded: preloaded} = a} ->
+        preloaded
+
+      {:error, _step, reason, _changes} ->
+        reason
+        # Handle error
+    end
+  end
+
+  def schema_from_table("identity_activities"), do: Algora.Accounts.Identity
+  def schema_from_table("user_activities"), do: Algora.Accounts.User
+  def schema_from_table("attempt_activities"), do: Algora.Bounties.Attempt
+  def schema_from_table("bonus_activities"), do: Algora.Bounties.Bonus
+  def schema_from_table("bounty_activities"), do: Algora.Bounties.Bounty
+  def schema_from_table("claim_activities"), do: Algora.Bounties.Claim
+  def schema_from_table("tip_activities"), do: Algora.Bounties.Tip
+  def schema_from_table("message_activities"), do: Algora.Chat.Message
+  def schema_from_table("thread_activities"), do: Algora.Chat.Thread
+  def schema_from_table("contract_activities"), do: Algora.Contracts.Contract
+  def schema_from_table("timesheet_activities"), do: Algora.Contracts.Timesheet
+  def schema_from_table("application_activities"), do: Algora.Jobs.Application
+  def schema_from_table("job_activities"), do: Algora.Jobs.Job
+  def schema_from_table("account_activities"), do: Algora.Payments.Account
+  def schema_from_table("customer_activities"), do: Algora.Payments.Customer
+  def schema_from_table("payment_method_activities"), do: Algora.Payments.PaymentMethod
+  def schema_from_table("platform_transaction_activities"), do: Algora.Payments.PlatformTransaction
+  def schema_from_table("transaction_activities"), do: Algora.Payments.Transaction
+  def schema_from_table("project_activities"), do: Algora.Projects.Project
+  def schema_from_table("review_activities"), do: Algora.Reviews.Project
+  def schema_from_table("installation_activities"), do: Algora.Workplace.Installation
+  def schema_from_table("ticket_activities"), do: Algora.Workspace.Ticket
+  def schema_from_table("repository_activities"), do: Algora.Workspace.Repository
+
+  def table_from_user_relation(:attempts), do: "attempt_activities"
+  def table_from_user_relation(:claims), do: "claim_activities"
+  def table_from_user_relation(:client_contracts), do: "contract_activities"
+  def table_from_user_relation(:connected_installations), do: "installation_activities"
+  def table_from_user_relation(:contractor_contracts), do: "contract_activities"
+  def table_from_user_relation(:created_bounties), do: "bounty_activities"
+  def table_from_user_relation(:owned_bounties), do: "bounty_activities"
+  def table_from_user_relation(:identities), do: "identity_activities"
+  def table_from_user_relation(:owned_installations), do: "installation_activities"
+  def table_from_user_relation(:projects), do: "project_activities"
+  def table_from_user_relation(:repositories), do: "repository_activities"
+  def table_from_user_relation(:transactions), do: "transaction_activities"
 end

lib/algora/activities/schemas/activity.ex

@@ -25,6 +25,7 @@ defmodule Algora.Activities.Activity do
     field :changes, :map, default: %{}
     field :trace_id, :string
     field :notify_users, {:array, :string}, default: []
+    field :assoc_name, :string, virtual: true
 
     belongs_to :user, Algora.Accounts.User
     belongs_to :previous_event, __MODULE__

lib/algora/contracts/contracts.ex

@@ -178,9 +178,7 @@ defmodule Algora.Contracts do
     |> foreign_key_constraint(:contract_id)
     |> foreign_key_constraint(:timesheet_id)
     |> foreign_key_constraint(:user_id)
-    |> Repo.insert_with_activity(%{
-      type: :transaction_created
-    })
+    |> Repo.insert()
   end
 
   defp initialize_debit(%{id: id, contract: contract, amount: amount, linked_transaction_id: linked_transaction_id}) do
@@ -205,9 +203,7 @@ defmodule Algora.Contracts do
     |> foreign_key_constraint(:contract_id)
     |> foreign_key_constraint(:timesheet_id)
     |> foreign_key_constraint(:user_id)
-    |> Repo.insert_with_activity(%{
-      type: :transaction_created
-    })
+    |> Repo.insert()
   end
 
   defp initialize_credit(%{id: id, contract: contract, amount: amount, linked_transaction_id: linked_transaction_id}) do
@@ -232,9 +228,7 @@ defmodule Algora.Contracts do
     |> foreign_key_constraint(:contract_id)
     |> foreign_key_constraint(:timesheet_id)
     |> foreign_key_constraint(:user_id)
-    |> Repo.insert_with_activity(%{
-      type: :transaction_created
-    })
+    |> Repo.insert()
   end
 
   defp initialize_transfer(%{contract: contract, amount: amount}) do
@@ -258,9 +252,7 @@ defmodule Algora.Contracts do
     |> foreign_key_constraint(:contract_id)
     |> foreign_key_constraint(:timesheet_id)
     |> foreign_key_constraint(:user_id)
-    |> Repo.insert_with_activity(%{
-      type: :transaction_created
-    })
+    |> Repo.insert()
   end
 
   defp initialize_prepayment_transaction(contract) do

test/algora/contracts_test.exs

@@ -235,24 +235,9 @@ defmodule Algora.ContractsTest do
       assert_activity_names_for_user(
         contract_a_0.contractor_id,
         [
-          :transaction_created,
           :contract_prepaid,
-          :transaction_created,
-          :transaction_created,
-          :transaction_created,
-          :transaction_created,
-          :transaction_status_change,
-          :transaction_status_change,
-          :transaction_status_change,
           :contract_paid,
           :contract_renewed,
-          :transaction_created,
-          :transaction_created,
-          :transaction_created,
-          :transaction_created,
-          :transaction_status_change,
-          :transaction_status_change,
-          :transaction_status_change,
           :contract_paid,
           :contract_renewed
         ]
@@ -265,6 +250,9 @@ defmodule Algora.ContractsTest do
                Activities.all_for_user(contract_b_0.contractor_id)
 
       assert_enqueued(worker: Activities.Notifier, worker: "Algora.Activities.Notifier")
+
+      assert [contract_activity | _rest] = Enum.reverse(Activities.all())
+      assert contract_activity.assoc.id == contract_a_0.id
     end
 
     test "prepayment fails when payment method is invalid" do