fetch user activities from nested children

Author: lastcanal

lib/algora/activities/activities.ex

@@ -2,6 +2,7 @@ defmodule Algora.Activities do
   @moduledoc false
   import Ecto.Query
 
+  alias Algora.Accounts.User
   alias Algora.Activities.Activity
   alias Algora.Repo
 
@@ -42,6 +43,9 @@ defmodule Algora.Activities do
     :owned_installations,
     :connected_installations,
     :client_contracts,
+    {:client_contracts, :transactions},
+    :client_contracts,
+    {:contractor_contracts, :transactions},
     :contractor_contracts
   ]
 
@@ -50,17 +54,27 @@ defmodule Algora.Activities do
 
   def base_query do
     [head | tail] = @tables
-
     query = head |> to_string() |> base_query()
 
-    Enum.reduce(tail, query, fn table_name, acc ->
-      new_query = table_name |> to_string() |> base_query()
+    Enum.reduce(tail, query, fn table_path, acc ->
+      new_query = base_query(table_path)
       union_all(new_query, ^acc)
     end)
   end
 
   def base_query(table_name) do
-    from(_e in {table_name, Activity})
+    from(_e in {to_string(table_name), Activity})
+  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
@@ -73,8 +87,17 @@ 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 Algora.Accounts.User,
+    from u in User,
       where: u.id == ^user_id,
       join: c in assoc(u, ^name),
       join: a in assoc(c, :activities),

test/algora/accounts_test.exs

@@ -26,11 +26,11 @@ defmodule Algora.AccountsTest do
       user_2 = insert(:user, tech_stack: ["rust", "c++"])
       org_1 = insert(:organization, seeded: false)
 
-      assert Accounts.fetch_developer(user_1.id) |> elem(1) |> Map.get(:id) == user_1.id
-      assert Accounts.fetch_developer_by([sort_by_tech_stack: ["rust"]]) |> elem(1) |> Map.get(:id) == user_2.id
+      assert user_1.id |> Accounts.fetch_developer() |> elem(1) |> Map.get(:id) == user_1.id
+      assert [sort_by_tech_stack: ["rust"]] |> Accounts.fetch_developer_by() |> elem(1) |> Map.get(:id) == user_2.id
 
-      assert Accounts.list_developers([]) |> length == 2
-      assert Accounts.list_orgs([]) |> length == 2
+      assert [] |> Accounts.list_developers() |> length() == 2
+      assert [] |> Accounts.list_orgs() |> length() == 1
 
       assert_activity_names_for_user(user_1.id, [])
       assert_activity_names_for_user(org_1.id, [])

test/algora/contracts_test.exs

@@ -206,59 +206,56 @@ defmodule Algora.ContractsTest do
       {:ok, contract_b_1} = Contracts.fetch_contract(contract_b_1.id)
       {:ok, {_txs2, _contract_b_2}} = Contracts.release_and_renew_contract(contract_b_1)
 
-      activities_per_contract = [
-        # :transaction_created,
-        # :transaction_created,
-        # :transaction_created,
-        # :transaction_created,
-        # :transaction_status_change,
-        # :transaction_status_change,
-        # :transaction_status_change,
-        :contract_paid
-      ]
-
-      activities_per_cycle =
-        activities_per_contract ++
-          [
-            :contract_renewed
-          ]
-
-      activities_per_group =
-        [
-          # :transaction_created,
-          :contract_prepaid
-        ] ++
-          activities_per_cycle ++
-          activities_per_cycle
-
       assert_activity_names(
         contract_a_0,
-        [
-          # :transaction_created,
-          :contract_prepaid
-        ] ++ activities_per_contract
+        [:contract_prepaid, :contract_paid]
       )
 
       assert_activity_names(
         contract_a_1,
-        [
-          :contract_renewed
-        ] ++ activities_per_contract
+        [:contract_renewed, :contract_paid]
       )
 
       assert_activity_names(
         "contract_activities",
-        activities_per_group ++ activities_per_group
+        [
+          :contract_prepaid,
+          :contract_paid,
+          :contract_renewed,
+          :contract_paid,
+          :contract_renewed,
+          :contract_prepaid,
+          :contract_paid,
+          :contract_renewed,
+          :contract_paid,
+          :contract_renewed
+        ]
       )
 
       assert_activity_names_for_user(
         contract_a_0.contractor_id,
-        activities_per_group
-      )
-
-      assert_activity_names_for_user(
-        contract_b_0.contractor_id,
-        activities_per_group
+        [
+          :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
+        ]
       )
 
       assert Activities.all_for_user(contract_a_0.client_id) !=