total rebase
[anni] / lib / pleroma / web / admin_api / controllers / report_controller.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.AdminAPI.ReportController do
6   use Pleroma.Web, :controller
7
8   import Pleroma.Web.ControllerHelper, only: [json_response: 3]
9
10   alias Pleroma.Activity
11   alias Pleroma.ModerationLog
12   alias Pleroma.ReportNote
13   alias Pleroma.Web.ActivityPub.Utils
14   alias Pleroma.Web.AdminAPI
15   alias Pleroma.Web.AdminAPI.Report
16   alias Pleroma.Web.CommonAPI
17   alias Pleroma.Web.Plugs.OAuthScopesPlug
18
19   require Logger
20
21   plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)
22   plug(OAuthScopesPlug, %{scopes: ["admin:read:reports"]} when action in [:index, :show])
23
24   plug(
25     OAuthScopesPlug,
26     %{scopes: ["admin:write:reports"]}
27     when action in [:update, :notes_create, :notes_delete]
28   )
29
30   action_fallback(AdminAPI.FallbackController)
31
32   defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.Admin.ReportOperation
33
34   def index(%{private: %{open_api_spex: %{params: params}}} = conn, _) do
35     reports = Utils.get_reports(params, params.page, params.page_size)
36
37     render(conn, "index.json", reports: reports)
38   end
39
40   def show(%{private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
41     with %Activity{} = report <- Activity.get_report(id) do
42       render(conn, "show.json", Report.extract_report_info(report))
43     else
44       _ -> {:error, :not_found}
45     end
46   end
47
48   def update(
49         %{
50           assigns: %{user: admin},
51           private: %{open_api_spex: %{body_params: %{reports: reports}}}
52         } = conn,
53         _
54       ) do
55     result =
56       Enum.map(reports, fn report ->
57         case CommonAPI.update_report_state(report.id, report.state) do
58           {:ok, activity} ->
59             report = Activity.get_by_id_with_user_actor(activity.id)
60
61             ModerationLog.insert_log(%{
62               action: "report_update",
63               actor: admin,
64               subject: activity,
65               subject_actor: report.user_actor
66             })
67
68             activity
69
70           {:error, message} ->
71             %{id: report.id, error: message}
72         end
73       end)
74
75     if Enum.any?(result, &Map.has_key?(&1, :error)) do
76       json_response(conn, :bad_request, result)
77     else
78       json_response(conn, :no_content, "")
79     end
80   end
81
82   def notes_create(
83         %{
84           assigns: %{user: user},
85           private: %{open_api_spex: %{body_params: %{content: content}, params: %{id: report_id}}}
86         } = conn,
87         _
88       ) do
89     with {:ok, _} <- ReportNote.create(user.id, report_id, content),
90          report <- Activity.get_by_id_with_user_actor(report_id) do
91       ModerationLog.insert_log(%{
92         action: "report_note",
93         actor: user,
94         subject: report,
95         subject_actor: report.user_actor,
96         text: content
97       })
98
99       json_response(conn, :no_content, "")
100     else
101       _ -> json_response(conn, :bad_request, "")
102     end
103   end
104
105   def notes_delete(
106         %{
107           assigns: %{user: user},
108           private: %{
109             open_api_spex: %{
110               params: %{
111                 id: note_id,
112                 report_id: report_id
113               }
114             }
115           }
116         } = conn,
117         _
118       ) do
119     with {:ok, note} <- ReportNote.destroy(note_id),
120          report <- Activity.get_by_id_with_user_actor(report_id) do
121       ModerationLog.insert_log(%{
122         action: "report_note_delete",
123         actor: user,
124         subject: report,
125         subject_actor: report.user_actor,
126         text: note.content
127       })
128
129       json_response(conn, :no_content, "")
130     else
131       _ -> json_response(conn, :bad_request, "")
132     end
133   end
134 end