Refactor Mobilizon.Federation.ActivityPub and add typespecs

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

lib/graphql/api/reports.ex

@@ -9,36 +9,29 @@ defmodule Mobilizon.GraphQL.API.Reports do
   alias Mobilizon.Reports.{Note, Report, ReportStatus}
   alias Mobilizon.Users.User
 
-  alias Mobilizon.Federation.ActivityPub
-  alias Mobilizon.Federation.ActivityPub.Activity
+  alias Mobilizon.Federation.ActivityPub.{Actions, Activity}
 
   @doc """
   Create a report/flag on an actor, and optionally on an event or on comments.
   """
-  @spec report(map()) :: {:ok, Activity.t(), Report.t()} | {:error, any()}
+  @spec report(map()) :: {:ok, Activity.t(), Report.t()} | {:error, Ecto.Changeset.t()}
   def report(args) do
-    case ActivityPub.flag(args, Map.get(args, :forward, false) == true) do
-      {:ok, %Activity{} = activity, %Report{} = report} ->
-        {:ok, activity, report}
-
-      err ->
-        {:error, err}
-    end
+    Actions.Flag.flag(args, Map.get(args, :forward, false) == true)
   end
 
   @doc """
   Update the state of a report
   """
   @spec update_report_status(Actor.t(), Report.t(), ReportStatus.t()) ::
-          {:ok, Report.t()} | {:error, String.t()}
+          {:ok, Report.t()} | {:error, Ecto.Changeset.t() | String.t()}
   def update_report_status(%Actor{} = actor, %Report{} = report, state) do
-    with {:valid_state, true} <-
-           {:valid_state, ReportStatus.valid_value?(state)},
-         {:ok, %Report{} = report} <- ReportsAction.update_report(report, %{"status" => state}),
-         {:ok, _} <- Admin.log_action(actor, "update", report) do
-      {:ok, report}
+    if ReportStatus.valid_value?(state) do
+      with {:ok, %Report{} = report} <- ReportsAction.update_report(report, %{"status" => state}) do
+        Admin.log_action(actor, "update", report)
+        {:ok, report}
+      end
     else
-      {:valid_state, false} -> {:error, "Unsupported state"}
+      {:error, "Unsupported state"}
     end
   end
 
@@ -46,49 +39,52 @@ defmodule Mobilizon.GraphQL.API.Reports do
   Create a note on a report
   """
   @spec create_report_note(Report.t(), Actor.t(), String.t()) ::
-          {:ok, Note.t()} | {:error, String.t()}
+          {:ok, Note.t()} | {:error, String.t() | Ecto.Changeset.t()}
   def create_report_note(
         %Report{id: report_id},
         %Actor{id: moderator_id, user_id: user_id} = moderator,
         content
       ) do
-    with %User{role: role} <- Users.get_user!(user_id),
-         {:role, true} <- {:role, role in [:administrator, :moderator]},
-         {:ok, %Note{} = note} <-
-           Mobilizon.Reports.create_note(%{
-             "report_id" => report_id,
-             "moderator_id" => moderator_id,
-             "content" => content
-           }),
-         {:ok, _} <- Admin.log_action(moderator, "create", note) do
-      {:ok, note}
+    %User{role: role} = Users.get_user!(user_id)
+
+    if role in [:administrator, :moderator] do
+      with {:ok, %Note{} = note} <-
+             Mobilizon.Reports.create_note(%{
+               "report_id" => report_id,
+               "moderator_id" => moderator_id,
+               "content" => content
+             }),
+           {:ok, _} <- Admin.log_action(moderator, "create", note) do
+        {:ok, note}
+      end
     else
-      {:role, false} ->
-        {:error, "You need to be a moderator or an administrator to create a note on a report"}
+      {:error, "You need to be a moderator or an administrator to create a note on a report"}
     end
   end
 
   @doc """
   Delete a report note
   """
-  @spec delete_report_note(Note.t(), Actor.t()) :: {:ok, Note.t()} | {:error, String.t()}
+  @spec delete_report_note(Note.t(), Actor.t()) ::
+          {:ok, Note.t()} | {:error, Ecto.Changeset.t() | String.t()}
   def delete_report_note(
         %Note{moderator_id: note_moderator_id} = note,
         %Actor{id: moderator_id, user_id: user_id} = moderator
       ) do
-    with {:same_actor, true} <- {:same_actor, note_moderator_id == moderator_id},
-         %User{role: role} <- Users.get_user!(user_id),
-         {:role, true} <- {:role, role in [:administrator, :moderator]},
-         {:ok, %Note{} = note} <-
-           Mobilizon.Reports.delete_note(note),
-         {:ok, _} <- Admin.log_action(moderator, "delete", note) do
-      {:ok, note}
-    else
-      {:role, false} ->
-        {:error, "You need to be a moderator or an administrator to create a note on a report"}
+    if note_moderator_id == moderator_id do
+      %User{role: role} = Users.get_user!(user_id)
 
-      {:same_actor, false} ->
-        {:error, "You can only remove your own notes"}
+      if role in [:administrator, :moderator] do
+        with {:ok, %Note{} = note} <-
+               Mobilizon.Reports.delete_note(note),
+             {:ok, _} <- Admin.log_action(moderator, "delete", note) do
+          {:ok, note}
+        end
+      else
+        {:error, "You need to be a moderator or an administrator to create a note on a report"}
+      end
+    else
+      {:error, "You can only remove your own notes"}
     end
   end
 end