Support old flag format

lib/pleroma/web/activity_pub/utils.ex

@@ -616,26 +616,31 @@ def make_flag_data(%{actor: actor, context: context, content: content} = params,
   def make_flag_data(_, _), do: %{}
 
   defp build_flag_object(%{account: account, statuses: statuses} = _) do
-    [account.ap_id] ++
+    [account.ap_id] ++ build_flag_object(%{statuses: statuses})
-      Enum.map(statuses || [], fn act ->
+  end
-        id =
-          case act do
-            %Activity{} = act -> act.data["id"]
-            act when is_map(act) -> act["id"]
-            act when is_binary(act) -> act
-          end
 
-        activity = Activity.get_by_ap_id_with_object(id)
+  defp build_flag_object(%{statuses: statuses}) do
-        actor = User.get_by_ap_id(activity.object.data["actor"])
+    Enum.map(statuses || [], &build_flag_object/1)
+  end
 
-        %{
+  defp build_flag_object(act) when is_map(act) or is_binary(act) do
-          "type" => "Note",
+    id =
-          "id" => activity.data["id"],
+      case act do
-          "content" => activity.object.data["content"],
+        %Activity{} = act -> act.data["id"]
-          "published" => activity.object.data["published"],
+        act when is_map(act) -> act["id"]
-          "actor" => AccountView.render("show.json", %{user: actor})
+        act when is_binary(act) -> act
-        }
+      end
-      end)
+
+    activity = Activity.get_by_ap_id_with_object(id)
+    actor = User.get_by_ap_id(activity.object.data["actor"])
+
+    %{
+      "type" => "Note",
+      "id" => activity.data["id"],
+      "content" => activity.object.data["content"],
+      "published" => activity.object.data["published"],
+      "actor" => AccountView.render("show.json", %{user: actor})
+    }
   end
 
   defp build_flag_object(_), do: []
@@ -692,7 +697,7 @@ def get_reports(params, page, page_size) do
     ActivityPub.fetch_activities([], params, :offset)
   end
 
-  @spec get_reports_grouped_by_status() :: %{
+  @spec get_reports_grouped_by_status(%{required(:activity) => String.t()}) :: %{
           required(:groups) => [
             %{
               required(:date) => String.t(),
@@ -704,30 +709,39 @@ def get_reports(params, page, page_size) do
           ],
           required(:total) => integer
         }
-  def get_reports_grouped_by_status do
+  def get_reports_grouped_by_status(groups) do
-    groups =
+    parsed_groups =
-      get_reported_status_ids()
+      groups
       |> Enum.map(fn entry ->
-        activity = Jason.decode!(entry.activity)
+        activity =
-        reports = get_reports_by_status_id(activity["id"])
+          case Jason.decode(entry.activity) do
-        max_date = Enum.max_by(reports, &NaiveDateTime.from_iso8601!(&1.data["published"]))
+            {:ok, activity} -> activity
-        actors = Enum.map(reports, & &1.user_actor)
+            _ -> build_flag_object(entry.activity)
+          end
 
-        %{
+        parse_report_group(activity)
-          date: max_date.data["published"],
-          account: activity["actor"],
-          status: %{
-            id: activity["id"],
-            content: activity["content"],
-            published: activity["published"]
-          },
-          actors: Enum.uniq(actors),
-          reports: reports
-        }
       end)
 
     %{
-      groups: groups
+      groups: parsed_groups
+    }
+  end
+
+  def parse_report_group(activity) do
+    reports = get_reports_by_status_id(activity["id"])
+    max_date = Enum.max_by(reports, &NaiveDateTime.from_iso8601!(&1.data["published"]))
+    actors = Enum.map(reports, & &1.user_actor)
+
+    %{
+      date: max_date.data["published"],
+      account: activity["actor"],
+      status: %{
+        id: activity["id"],
+        content: activity["content"],
+        published: activity["published"]
+      },
+      actors: Enum.uniq(actors),
+      reports: reports
     }
   end
 
@@ -740,13 +754,13 @@ def get_reports_by_status_id(ap_id) do
     |> Repo.all()
   end
 
-  @spec get_reported_status_ids() :: [
+  @spec get_reported_activities() :: [
           %{
             required(:activity) => String.t(),
             required(:date) => String.t()
           }
         ]
-  def get_reported_status_ids do
+  def get_reported_activities do
     from(a in Activity,
       where: fragment("(?)->>'type' = 'Flag'", a.data),
       select: %{

lib/pleroma/web/admin_api/admin_api_controller.ex

@@ -625,9 +625,11 @@ def list_reports(conn, params) do
   end
 
   def list_grouped_reports(conn, _params) do
+    reports = Utils.get_reported_activities()
+
     conn
     |> put_view(ReportView)
-    |> render("index_grouped.json", Utils.get_reports_grouped_by_status())
+    |> render("index_grouped.json", Utils.get_reports_grouped_by_status(reports))
   end
 
   def report_show(conn, %{"id" => id}) do

test/web/activity_pub/utils_test.exs

@@ -636,4 +636,47 @@ test "removes actor from announcements" do
       assert updated_object.data["announcement_count"] == 1
     end
   end
+
+  describe "get_reports_grouped_by_status/1" do
+    setup do
+      [reporter, target_user] = insert_pair(:user)
+      first_status = insert(:note_activity, user: target_user)
+      second_status = insert(:note_activity, user: target_user)
+
+      CommonAPI.report(reporter, %{
+        "account_id" => target_user.id,
+        "comment" => "I feel offended",
+        "status_ids" => [first_status.id]
+      })
+
+      CommonAPI.report(reporter, %{
+        "account_id" => target_user.id,
+        "comment" => "I feel offended2",
+        "status_ids" => [second_status.id]
+      })
+
+      data = [%{activity: first_status.data["id"]}, %{activity: second_status.data["id"]}]
+
+      {:ok,
+       %{
+         first_status: first_status,
+         second_status: second_status,
+         data: data
+       }}
+    end
+
+    test "works for deprecated reports format", %{
+      first_status: first_status,
+      second_status: second_status,
+      data: data
+    } do
+      groups = Utils.get_reports_grouped_by_status(data).groups
+
+      first_group = Enum.find(groups, &(&1.status.id == first_status.data["id"]))
+      second_group = Enum.find(groups, &(&1.status.id == second_status.data["id"]))
+
+      assert first_group.status.id == first_status.data["id"]
+      assert second_group.status.id == second_status.data["id"]
+    end
+  end
 end