Introduce backend for reports

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

test/mobilizon/service/activity_pub/transmogrifier_test.exs

@@ -676,6 +676,29 @@ defmodule Mobilizon.Service.ActivityPub.TransmogrifierTest do
 
     #       :error = Transmogrifier.handle_incoming(data)
     #     end
+
+    test "it accepts Flag activities" do
+      %Actor{url: reporter_url} = _reporter = insert(:actor)
+      %Actor{url: reported_url} = reported = insert(:actor)
+
+      %Comment{url: comment_url} = _comment = insert(:comment, actor: reported)
+
+      message = %{
+        "@context" => "https://www.w3.org/ns/activitystreams",
+        "cc" => [reported_url],
+        "object" => [reported_url, comment_url],
+        "type" => "Flag",
+        "content" => "blocked AND reported!!!",
+        "actor" => reporter_url
+      }
+
+      assert {:ok, activity, _} = Transmogrifier.handle_incoming(message)
+
+      assert activity.data["object"] == [reported_url, comment_url]
+      assert activity.data["content"] == "blocked AND reported!!!"
+      assert activity.data["actor"] == reporter_url
+      assert activity.data["cc"] == [reported_url]
+    end
   end
 
   describe "prepare outgoing" do

test/mobilizon/service/admin/action_log_service_test.exs

@@ -0,0 +1,43 @@
+defmodule Mobilizon.Service.Admin.ActionLogServiceTest do
+  @moduledoc """
+  Test the ActionLogService module
+  """
+  use Mobilizon.DataCase
+  import Mobilizon.Service.Admin.ActionLogService
+  alias Mobilizon.Reports.{Report, Note}
+  alias Mobilizon.Admin.ActionLog
+  import Mobilizon.Factory
+
+  setup do
+    moderator_user = insert(:user, role: :moderator)
+    moderator_actor = insert(:actor, user: moderator_user)
+    {:ok, moderator: moderator_actor}
+  end
+
+  describe "action_log_creation" do
+    test "log a report update", %{moderator: moderator} do
+      %Report{id: _report_id} = report = insert(:report)
+
+      assert {:ok,
+              %ActionLog{
+                target_type: "Elixir.Mobilizon.Reports.Report",
+                target_id: report_id,
+                action: "update",
+                actor: moderator
+              }} = log_action(moderator, "update", report)
+    end
+
+    test "log the creation of a report note", %{moderator: moderator} do
+      %Report{} = report = insert(:report)
+      %Note{id: _note_id} = report = insert(:report_note, report: report)
+
+      assert {:ok,
+              %ActionLog{
+                target_type: "Elixir.Mobilizon.Reports.Note",
+                target_id: note_id,
+                action: "create",
+                actor: moderator
+              }} = log_action(moderator, "create", report)
+    end
+  end
+end

test/mobilizon_web/api/report_test.exs

@@ -0,0 +1,217 @@
+defmodule MobilizonWeb.API.ReportTest do
+  use Mobilizon.DataCase
+
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Events.Comment
+  alias Mobilizon.Actors.Actor
+  alias MobilizonWeb.API.Reports
+  alias Mobilizon.Reports.{Report, Note}
+  alias Mobilizon.Activity
+  alias Mobilizon.Users.User
+  alias Mobilizon.Users
+
+  import Mobilizon.Factory
+
+  describe "reports" do
+    test "creates a report on a event" do
+      %Actor{id: reporter_id, url: reporter_url} = insert(:actor)
+      %Actor{id: reported_id, url: reported_url} = reported = insert(:actor)
+
+      %Event{id: event_id, url: event_url} = _event = insert(:event, organizer_actor: reported)
+
+      comment = "This is not acceptable"
+
+      assert {:ok, %Activity{} = flag_activity, _} =
+               Reports.report(%{
+                 reporter_actor_id: reporter_id,
+                 reported_actor_id: reported_id,
+                 report_content: comment,
+                 event_id: event_id,
+                 comments_ids: []
+               })
+
+      assert %Activity{
+               actor: ^reporter_url,
+               data: %{
+                 "type" => "Flag",
+                 "cc" => [],
+                 "content" => ^comment,
+                 "object" => [^reported_url, ^event_url],
+                 "state" => "open"
+               }
+             } = flag_activity
+    end
+
+    test "creates a report on several comments" do
+      %Actor{id: reporter_id, url: reporter_url} = insert(:actor)
+      %Actor{id: reported_id, url: reported_url} = reported = insert(:actor)
+
+      %Comment{id: comment_1_id, url: comment_1_url} =
+        _comment_1 = insert(:comment, actor: reported)
+
+      %Comment{id: comment_2_id, url: comment_2_url} =
+        _comment_2 = insert(:comment, actor: reported)
+
+      comment = "This is really not acceptable"
+
+      assert {:ok, %Activity{} = flag_activity, _} =
+               Reports.report(%{
+                 reporter_actor_id: reporter_id,
+                 reported_actor_id: reported_id,
+                 report_content: comment,
+                 event_id: nil,
+                 comments_ids: [comment_1_id, comment_2_id]
+               })
+
+      assert %Activity{
+               actor: ^reporter_url,
+               data: %{
+                 "type" => "Flag",
+                 "cc" => [],
+                 "content" => ^comment,
+                 "object" => [^reported_url, ^comment_1_url, ^comment_2_url],
+                 "state" => "open"
+               }
+             } = flag_activity
+    end
+
+    test "creates a report that gets federated" do
+      %Actor{id: reporter_id, url: reporter_url} = insert(:actor)
+      %Actor{id: reported_id, url: reported_url} = reported = insert(:actor)
+
+      %Comment{id: comment_1_id, url: comment_1_url} =
+        _comment_1 = insert(:comment, actor: reported)
+
+      %Comment{id: comment_2_id, url: comment_2_url} =
+        _comment_2 = insert(:comment, actor: reported)
+
+      comment = "This is really not acceptable, remote admin I don't know"
+      encoded_comment = Mobilizon.Service.Formatter.html_escape(comment, "text/plain")
+
+      assert {:ok, %Activity{} = flag_activity, _} =
+               Reports.report(%{
+                 reporter_actor_id: reporter_id,
+                 reported_actor_id: reported_id,
+                 report_content: comment,
+                 event_id: nil,
+                 comments_ids: [comment_1_id, comment_2_id],
+                 forward: true
+               })
+
+      assert %Activity{
+               actor: ^reporter_url,
+               data: %{
+                 "type" => "Flag",
+                 "actor" => ^reporter_url,
+                 "cc" => [^reported_url],
+                 "content" => ^encoded_comment,
+                 "object" => [^reported_url, ^comment_1_url, ^comment_2_url],
+                 "state" => "open"
+               }
+             } = flag_activity
+    end
+
+    test "updates report state" do
+      %Actor{id: reporter_id} = insert(:actor)
+      %Actor{id: reported_id} = reported = insert(:actor)
+
+      %Comment{id: comment_1_id} = _comment_1 = insert(:comment, actor: reported)
+
+      assert {:ok, %Activity{} = flag_activity, %Report{id: report_id} = _report} =
+               Reports.report(%{
+                 reporter_actor_id: reporter_id,
+                 reported_actor_id: reported_id,
+                 report_content: "This is not a nice thing",
+                 event_id: nil,
+                 comments_ids: [comment_1_id],
+                 forward: true
+               })
+
+      %Report{} = report = Mobilizon.Reports.get_report(report_id)
+
+      %User{} = manager_user = insert(:user, role: :moderator)
+      %Actor{} = manager_actor = insert(:actor, user: manager_user)
+
+      {:ok, new_report} = Reports.update_report_status(manager_actor, report, :resolved)
+
+      assert new_report.status == :resolved
+    end
+
+    test "updates report state with not acceptable status" do
+      %Actor{id: reporter_id} = insert(:actor)
+      %Actor{id: reported_id} = reported = insert(:actor)
+
+      %Comment{id: comment_1_id} = _comment_1 = insert(:comment, actor: reported)
+
+      assert {:ok, %Activity{} = flag_activity, %Report{id: report_id} = _report} =
+               Reports.report(%{
+                 reporter_actor_id: reporter_id,
+                 reported_actor_id: reported_id,
+                 report_content: "This is not a nice thing",
+                 event_id: nil,
+                 comments_ids: [comment_1_id],
+                 forward: true
+               })
+
+      %Report{} = report = Mobilizon.Reports.get_report(report_id)
+
+      %Actor{} = manager_actor = insert(:actor)
+
+      {:error, "Unsupported state"} = Reports.update_report_status(manager_actor, report, :test)
+    end
+  end
+
+  describe "note reports" do
+    test "creates a note on a report" do
+      %User{} = moderator_user = insert(:user, role: :moderator)
+      %Actor{} = moderator_actor = insert(:actor, user: moderator_user)
+      %Report{} = report = insert(:report)
+
+      assert {:ok, %Note{} = _note} =
+               Reports.create_report_note(
+                 report,
+                 moderator_actor,
+                 "I'll take care of this later today"
+               )
+    end
+
+    test "doesn't create a note on a report when not moderator" do
+      %User{} = user = insert(:user)
+      %Actor{} = actor = insert(:actor, user: user)
+      %Report{} = report = insert(:report)
+
+      assert {:error,
+              "You need to be a moderator or an administrator to create a note on a report"} =
+               Reports.create_report_note(report, actor, "I'll take care of this later today")
+    end
+
+    test "deletes a note on a report" do
+      %User{} = moderator_user = insert(:user, role: :moderator)
+      %Actor{} = moderator_actor = insert(:actor, user: moderator_user)
+      %Note{} = note = insert(:report_note, moderator: moderator_actor)
+      assert {:ok, %Note{}} = Reports.delete_report_note(note, moderator_actor)
+    end
+
+    test "deletes a note on a report with a different moderator actor" do
+      %Note{} = note = insert(:report_note)
+
+      %User{} = other_moderator_user = insert(:user, role: :moderator)
+      %Actor{} = other_moderator_actor = insert(:actor, user: other_moderator_user)
+
+      assert {:error, "You can only remove your own notes"} =
+               Reports.delete_report_note(note, other_moderator_actor)
+    end
+
+    test "try deletes a note on a report with a actor not moderator anymore" do
+      %User{} = moderator_user = insert(:user, role: :moderator)
+      %Actor{} = moderator_actor = insert(:actor, user: moderator_user)
+      %Note{} = note = insert(:report_note, moderator: moderator_actor)
+
+      Users.update_user(moderator_user, %{role: :user})
+
+      assert {:error,
+              "You need to be a moderator or an administrator to create a note on a report"} =
+               Reports.delete_report_note(note, moderator_actor)
+    end
+  end
+end

test/mobilizon_web/resolvers/admin_resolver_test.exs

@@ -0,0 +1,82 @@
+defmodule MobilizonWeb.Resolvers.AdminResolverTest do
+  alias MobilizonWeb.AbsintheHelpers
+  use MobilizonWeb.ConnCase
+  import Mobilizon.Factory
+
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Users.User
+  alias Mobilizon.Reports.{Report, Note}
+
+  describe "Resolver: List the action logs" do
+    @note_content "This a note on a report"
+    test "list_action_logs/3 list action logs", %{conn: conn} do
+      %User{} = user_moderator = insert(:user, role: :moderator)
+      %Actor{} = moderator = insert(:actor, user: user_moderator)
+
+      %User{} = user_moderator_2 = insert(:user, role: :moderator)
+      %Actor{} = moderator_2 = insert(:actor, user: user_moderator_2)
+
+      %Report{} = report = insert(:report)
+      MobilizonWeb.API.Reports.update_report_status(moderator, report, "resolved")
+
+      {:ok, %Note{} = note} =
+        MobilizonWeb.API.Reports.create_report_note(report, moderator_2, @note_content)
+
+      MobilizonWeb.API.Reports.delete_report_note(note, moderator_2)
+
+      query = """
+      {
+        actionLogs {
+          action,
+          actor {
+            preferredUsername
+          },
+          object {
+            ... on Report {
+              id,
+              status
+            },
+            ... on ReportNote {
+              content
+            }
+          }
+        }
+      }
+      """
+
+      res =
+        conn
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "actionLogs"))
+
+      assert json_response(res, 200)["errors"] |> hd |> Map.get("message") ==
+               "You need to be logged-in and a moderator to list action logs"
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "actionLogs"))
+
+      assert json_response(res, 200)["errors"] == nil
+
+      assert json_response(res, 200)["data"]["actionLogs"] |> length == 3
+
+      assert json_response(res, 200)["data"]["actionLogs"] == [
+               %{
+                 "action" => "report_update_resolved",
+                 "actor" => %{"preferredUsername" => moderator.preferred_username},
+                 "object" => %{"id" => to_string(report.id), "status" => "RESOLVED"}
+               },
+               %{
+                 "action" => "note_creation",
+                 "actor" => %{"preferredUsername" => moderator_2.preferred_username},
+                 "object" => %{"content" => @note_content}
+               },
+               %{
+                 "action" => "note_deletion",
+                 "actor" => %{"preferredUsername" => moderator_2.preferred_username},
+                 "object" => %{"content" => @note_content}
+               }
+             ]
+    end
+  end
+end

test/mobilizon_web/resolvers/report_resolver_test.exs

@@ -0,0 +1,366 @@
+defmodule MobilizonWeb.Resolvers.ReportResolverTest do
+  alias MobilizonWeb.AbsintheHelpers
+  use MobilizonWeb.ConnCase
+  import Mobilizon.Factory
+
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Users.User
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Reports.{Report, Note}
+
+  describe "Resolver: Report a content" do
+    test "create_report/3 creates a report", %{conn: conn} do
+      %User{} = user_reporter = insert(:user)
+      %Actor{} = reporter = insert(:actor, user: user_reporter)
+      %Actor{} = reported = insert(:actor)
+      %Event{} = event = insert(:event, organizer_actor: reported)
+
+      mutation = """
+          mutation {
+            createReport(
+              reporter_actor_id: #{reporter.id},
+              reported_actor_id: #{reported.id},
+              event_id: #{event.id},
+              report_content: "This is an issue"
+            ) {
+                content,
+                reporter {
+                  id
+                },
+                event {
+                  id
+                },
+                status
+              }
+            }
+      """
+
+      res =
+        conn
+        |> auth_conn(user_reporter)
+        |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
+
+      assert json_response(res, 200)["errors"] == nil
+      assert json_response(res, 200)["data"]["createReport"]["content"] == "This is an issue"
+      assert json_response(res, 200)["data"]["createReport"]["status"] == "OPEN"
+      assert json_response(res, 200)["data"]["createReport"]["event"]["id"] == event.id
+      assert json_response(res, 200)["data"]["createReport"]["reporter"]["id"] == reporter.id
+    end
+
+    test "create_report/3 without being connected doesn't create any report", %{conn: conn} do
+      %Actor{} = reported = insert(:actor)
+
+      mutation = """
+          mutation {
+            createReport(
+              reported_actor_id: #{reported.id},
+              reporter_actor_id: 5,
+              report_content: "This is an issue"
+            ) {
+                content
+              }
+            }
+      """
+
+      res =
+        conn
+        |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
+
+      assert json_response(res, 200)["errors"] |> hd |> Map.get("message") ==
+               "You need to be logged-in to create reports"
+    end
+  end
+
+  describe "Resolver: update a report" do
+    test "update_report/3 updates the report's status", %{conn: conn} do
+      %User{} = user_moderator = insert(:user, role: :moderator)
+      %Actor{} = moderator = insert(:actor, user: user_moderator)
+      %Report{} = report = insert(:report)
+
+      mutation = """
+          mutation {
+            updateReportStatus(
+              report_id: #{report.id},
+              moderator_id: #{moderator.id},
+              status: RESOLVED
+            ) {
+                content,
+                reporter {
+                  id
+                },
+                event {
+                  id
+                },
+                status
+              }
+            }
+      """
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
+
+      assert json_response(res, 200)["errors"] == nil
+
+      assert json_response(res, 200)["data"]["updateReportStatus"]["content"] ==
+               "This is problematic"
+
+      assert json_response(res, 200)["data"]["updateReportStatus"]["status"] == "RESOLVED"
+
+      assert json_response(res, 200)["data"]["updateReportStatus"]["reporter"]["id"] ==
+               report.reporter.id
+    end
+
+    test "create_report/3 without being connected doesn't create any report", %{conn: conn} do
+      %User{} = user_moderator = insert(:user, role: :moderator)
+      %Actor{} = moderator = insert(:actor, user: user_moderator)
+      %Report{} = report = insert(:report)
+
+      mutation = """
+          mutation {
+            updateReportStatus(
+              report_id: #{report.id},
+              moderator_id: #{moderator.id},
+              status: RESOLVED
+            ) {
+                content
+              }
+            }
+      """
+
+      res =
+        conn
+        |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
+
+      assert json_response(res, 200)["errors"] |> hd |> Map.get("message") ==
+               "You need to be logged-in and a moderator to update a report"
+    end
+  end
+
+  describe "Resolver: Get list of reports" do
+    test "get an empty list of reports", %{conn: conn} do
+      %User{} = user_moderator = insert(:user, role: :moderator)
+
+      query = """
+      {
+        reports {
+          id,
+          reported {
+            preferredUsername
+          }
+        }
+      }
+      """
+
+      res =
+        conn
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "report"))
+
+      assert json_response(res, 200)["errors"] |> hd |> Map.get("message") ==
+               "You need to be logged-in and a moderator to list reports"
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "report"))
+
+      assert json_response(res, 200)["errors"] == nil
+      assert json_response(res, 200)["data"]["reports"] == []
+    end
+
+    test "get a list of reports", %{conn: conn} do
+      %User{} = user_moderator = insert(:user, role: :moderator)
+
+      %Report{id: report_1_id} = insert(:report)
+      %Report{id: report_2_id} = insert(:report)
+      %Report{id: report_3_id} = insert(:report)
+
+      query = """
+      {
+        reports {
+          id,
+          reported {
+            preferredUsername
+          }
+        }
+      }
+      """
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "report"))
+
+      assert json_response(res, 200)["errors"] == nil
+
+      assert json_response(res, 200)["data"]["reports"]
+             |> Enum.map(fn report -> Map.get(report, "id") end) ==
+               Enum.map([report_1_id, report_2_id, report_3_id], &to_string/1)
+
+      query = """
+      {
+        reports(page: 2, limit: 2) {
+          id,
+          reported {
+            preferredUsername
+          }
+        }
+      }
+      """
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "report"))
+
+      assert json_response(res, 200)["errors"] == nil
+      assert json_response(res, 200)["data"]["reports"] |> length == 1
+
+      query = """
+      {
+        reports(page: 3, limit: 2) {
+          id,
+          reported {
+            preferredUsername
+          }
+        }
+      }
+      """
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "report"))
+
+      assert json_response(res, 200)["errors"] == nil
+      assert json_response(res, 200)["data"]["reports"] |> length == 0
+    end
+  end
+
+  describe "Resolver: View a report" do
+    test "view a report", %{conn: conn} do
+      %User{} = user_moderator = insert(:user, role: :moderator)
+      %Actor{} = insert(:actor, user: user_moderator)
+      %Actor{} = reporter = insert(:actor)
+      %Report{} = report = insert(:report, reporter: reporter)
+
+      query = """
+      {
+        report (id: "#{report.id}") {
+          id,
+          reported {
+            preferredUsername
+          },
+          reporter {
+            preferredUsername
+          },
+          event {
+            title
+          },
+          comments {
+            text
+          },
+          content
+        }
+      }
+      """
+
+      res =
+        conn
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "report"))
+
+      assert json_response(res, 200)["errors"] |> hd |> Map.get("message") ==
+               "You need to be logged-in and a moderator to view a report"
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> get("/api", AbsintheHelpers.query_skeleton(query, "report"))
+
+      assert json_response(res, 200)["errors"] == nil
+
+      assert json_response(res, 200)["data"]["report"]["reported"]["preferredUsername"] ==
+               report.reported.preferred_username
+
+      assert json_response(res, 200)["data"]["report"]["reporter"]["preferredUsername"] ==
+               reporter.preferred_username
+
+      assert json_response(res, 200)["data"]["report"]["content"] == report.content
+      assert json_response(res, 200)["data"]["report"]["event"]["title"] == report.event.title
+
+      assert json_response(res, 200)["data"]["report"]["comments"] |> hd |> Map.get("text") ==
+               report.comments |> hd |> Map.get(:text)
+    end
+  end
+
+  describe "Resolver: Add a note on a report" do
+    @report_note_content "I agree with this this report"
+
+    test "create_report_note/3 creates a report note", %{conn: conn} do
+      %User{} = user_moderator = insert(:user, role: :moderator)
+      %Actor{id: moderator_id} = moderator = insert(:actor, user: user_moderator)
+      %Report{id: report_id} = insert(:report)
+
+      mutation = """
+          mutation {
+            createReportNote(
+              moderator_id: #{moderator_id},
+              report_id: #{report_id},
+              content: "#{@report_note_content}"
+            ) {
+                content,
+                moderator {
+                  preferred_username
+                },
+                report {
+                  id
+                }
+              }
+            }
+      """
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
+
+      assert json_response(res, 200)["errors"] == nil
+
+      assert json_response(res, 200)["data"]["createReportNote"]["content"] ==
+               @report_note_content
+
+      assert json_response(res, 200)["data"]["createReportNote"]["moderator"][
+               "preferred_username"
+             ] == moderator.preferred_username
+
+      assert json_response(res, 200)["data"]["createReportNote"]["report"]["id"] ==
+               to_string(report_id)
+    end
+
+    test "delete_report_note deletes a report note", %{conn: conn} do
+      %User{} = user_moderator = insert(:user, role: :moderator)
+      %Actor{id: moderator_id} = moderator = insert(:actor, user: user_moderator)
+      %Note{id: report_note_id} = insert(:report_note, moderator: moderator)
+
+      mutation = """
+          mutation {
+            deleteReportNote(
+              moderator_id: #{moderator_id},
+              note_id: #{report_note_id},
+            ) {
+                id
+              }
+            }
+      """
+
+      res =
+        conn
+        |> auth_conn(user_moderator)
+        |> post("/api", AbsintheHelpers.mutation_skeleton(mutation))
+
+      assert json_response(res, 200)["errors"] == nil
+      assert json_response(res, 200)["data"]["deleteReportNote"]["id"] == report_note_id
+    end
+  end
+end

test/support/factory.ex

@@ -202,4 +202,24 @@ defmodule Mobilizon.Factory do
       actor: build(:actor)
     }
   end
+
+  def report_factory do
+    %Mobilizon.Reports.Report{
+      content: "This is problematic",
+      status: :open,
+      uri: "http://mobilizon.test/report/deae1020-54b8-47df-9eea-d8c0e943e57f/activity",
+      reported: build(:actor),
+      reporter: build(:actor),
+      event: build(:event),
+      comments: build_list(1, :comment)
+    }
+  end
+
+  def report_note_factory do
+    %Mobilizon.Reports.Note{
+      content: "My opinion",
+      moderator: build(:actor),
+      report: build(:report)
+    }
+  end
 end