satisfy the dialyzer

Author: lastcanal

lib/algora/activities/activities.ex

@@ -62,21 +62,25 @@ defmodule Algora.Activities do
     end)
   end
 
-  def base_query(table_name) do
-    from(_e in {to_string(table_name), Activity})
+  def base_query(table_name) when is_atom(table_name) do
+    table_name |> to_string() |> base_query()
   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)
+  def base_query(table_name) when is_binary(table_name) do
+    from(_e in {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
     [head | tail] = @user_attributes
     first_query = base_query_for_user(user_id, head)

lib/algora/jobs/schemas/application.ex

@@ -2,6 +2,8 @@ defmodule Algora.Jobs.Application do
   @moduledoc false
   use Algora.Schema
 
+  alias Algora.Activities.Activity
+
   typed_schema "applications" do
     belongs_to :job, Algora.Jobs.Job
     belongs_to :user, Algora.Accounts.User

lib/algora/jobs/schemas/job.ex

@@ -2,6 +2,8 @@ defmodule Algora.Jobs.Job do
   @moduledoc false
   use Algora.Schema
 
+  alias Algora.Activities.Activity
+
   typed_schema "jobs" do
     belongs_to :user, Algora.Accounts.User
 

lib/algora/repo.ex

@@ -69,7 +69,7 @@ defmodule Algora.Repo do
     )
   end
 
-  @spec insert_with_activity(Ecto.Changeset.t(), struct()) ::
+  @spec insert_with_activity(Ecto.Changeset.t(), map()) ::
           {:ok, struct()} | {:error, Ecto.Changeset.t()}
   def insert_with_activity(changeset, activity) do
     Ecto.Multi.new()
@@ -79,7 +79,7 @@ defmodule Algora.Repo do
     |> extract_target()
   end
 
-  @spec update_with_activity(Ecto.Changeset.t(), struct()) ::
+  @spec update_with_activity(Ecto.Changeset.t(), map()) ::
           {:ok, struct()} | {:error, Ecto.Changeset.t()}
   def update_with_activity(changeset, activity) do
     Ecto.Multi.new()
@@ -89,7 +89,7 @@ defmodule Algora.Repo do
     |> extract_target()
   end
 
-  @spec delete_with_activity(Ecto.Changeset.t(), struct()) ::
+  @spec delete_with_activity(Ecto.Changeset.t(), map()) ::
           {:ok, struct()} | {:error, Ecto.Changeset.t()}
   def delete_with_activity(changeset, activity) do
     Ecto.Multi.new()
@@ -99,8 +99,7 @@ defmodule Algora.Repo do
     |> extract_target()
   end
 
-  @spec with_activity(Ecto.Multi.t(), struct()) ::
-          {:ok, struct()} | {:error, Ecto.Changeset.t()}
+  @spec with_activity(Ecto.Multi.t(), map()) :: Ecto.Multi.t()
   def with_activity(multi, activity) do
     multi
     |> Ecto.Multi.insert(:activity, fn %{target: target} ->

lib/algora/signal.ex

@@ -2,16 +2,26 @@ defmodule Algora.Signal do
   @moduledoc false
   @provider Appsignal
 
-  defdelegate send_error(exception, stacktrace), to: @provider
-  defdelegate send_error(kind, reason, stacktrace), to: @provider
+  def send_error(%Ecto.Changeset{} = error, exception) do
+    send_error(error, exception, [])
+  end
+
+  def send_error(%Stripe.Error{} = error, exception) do
+    send_error(error, exception, [])
+  end
 
-  def send_stripe_error(%Stripe.Error{} = error, exception, stacktrace \\ nil) do
+  def send_error(%Stripe.Error{} = error, exception, stacktrace) do
     case error do
       %{extra: %{raw_error: %{"message" => message}}} ->
         send_error(%{exception | message: message}, stacktrace)
 
       _error ->
         send_error(%{exception | message: "Unknown Stripe error"}, stacktrace)
     end
+    :ok
   end
+
+  defdelegate send_error(exception, stacktrace), to: @provider
+  defdelegate send_error(kind, reason, stacktrace), to: @provider
+
 end

lib/algora_web/live/user/transactions_live.ex

@@ -85,10 +85,10 @@ defmodule AlgoraWeb.User.TransactionsLive do
       {:ok, %{url: url}} ->
         {:noreply, redirect(socket, external: url)}
 
-      {:error, %Stripe.Error{} = error} ->
-        Algora.Notifier.notify_stripe_account_link_error(socket.assigns.current_user, error)
-        Algora.Signal.send_stripe_error(error, %StripeAccountLinkError{})
-        {:noreply, put_flash(socket, :error, "Failed to link payout account for your country")}
+     #{:error, %Stripe.Error{} = error} ->
+     #  Algora.Notifier.notify_stripe_account_link_error(socket.assigns.current_user, error)
+     #  Algora.Signal.send_error(error, %StripeAccountLinkError{})
+     #  {:noreply, put_flash(socket, :error, "Failed to link payout account for your country")}
 
       {:error, _reason} ->
         {:noreply, put_flash(socket, :error, "Something went wrong")}
@@ -109,10 +109,10 @@ defmodule AlgoraWeb.User.TransactionsLive do
            {:ok, %{url: url}} <- Payments.create_account_link(account, AlgoraWeb.Endpoint.url()) do
         {:noreply, redirect(socket, external: url)}
       else
-        {:error, %Stripe.Error{} = error} ->
-          Algora.Notifier.notify_stripe_account_link_error(socket.assigns.current_user, error)
-          Algora.Signal.send_stripe_error(error, %StripeAccountCreateError{})
-          {:noreply, put_flash(socket, :error, "Failed to create payout account")}
+       #{:error, %Stripe.Error{} = error} ->
+       #  Algora.Notifier.notify_stripe_account_link_error(socket.assigns.current_user, error)
+       #  Algora.Signal.send_error(error, %StripeAccountCreateError{})
+       #  {:noreply, put_flash(socket, :error, "Failed to create payout account")}
 
         {:error, _reason} ->
           {:noreply, put_flash(socket, :error, "Something went wrong")}
@@ -140,9 +140,9 @@ defmodule AlgoraWeb.User.TransactionsLive do
          |> assign(:show_manage_payout_drawer, false)
          |> put_flash(:info, "Payout account deleted successfully")}
 
-      {:error, %Stripe.Error{} = error} ->
-        Algora.Signal.send_stripe_error(error, %StripeAccountDeleteError{})
-        {:noreply, put_flash(socket, :error, "Failed to delete payout account")}
+     #{:error, %Stripe.Error{} = error} ->
+     #  Algora.Signal.send_error(error, %StripeAccountDeleteError{})
+     #  {:noreply, put_flash(socket, :error, "Failed to delete payout account")}
 
       {:error, _reason} ->
         {:noreply,