debianize-mobilizon/lib/graphql/resolvers/report.ex

122 lines
3.7 KiB
Elixir
Raw Normal View History

2020-01-26 20:34:25 +01:00
defmodule Mobilizon.GraphQL.Resolvers.Report do
@moduledoc """
2019-09-22 16:26:23 +02:00
Handles the report-related GraphQL calls.
"""
2019-09-22 16:26:23 +02:00
import Mobilizon.Users.Guards
alias Mobilizon.Actors
2019-09-22 16:26:23 +02:00
alias Mobilizon.Actors.Actor
alias Mobilizon.Reports
alias Mobilizon.Reports.{Note, Report}
alias Mobilizon.Users.User
2019-09-22 16:26:23 +02:00
2020-01-26 21:11:16 +01:00
alias Mobilizon.GraphQL.API
2019-09-07 19:54:11 +02:00
def list_reports(
_parent,
%{page: page, limit: limit, status: status},
2019-09-07 19:54:11 +02:00
%{context: %{current_user: %User{role: role}}}
)
when is_moderator(role) do
{:ok, Mobilizon.Reports.list_reports(page, limit, :updated_at, :desc, status)}
end
def list_reports(_parent, _args, _resolution) do
{:error, "You need to be logged-in and a moderator to list reports"}
end
2019-09-07 19:54:11 +02:00
def get_report(_parent, %{id: id}, %{context: %{current_user: %User{role: role}}})
when is_moderator(role) do
case Mobilizon.Reports.get_report(id) do
%Report{} = report ->
{:ok, report}
nil ->
{:error, "Report not found"}
end
end
def get_report(_parent, _args, _resolution) do
{:error, "You need to be logged-in and a moderator to view a report"}
end
@doc """
Create a report
"""
def create_report(
_parent,
%{reporter_id: reporter_id} = args,
%{context: %{current_user: user}} = _resolution
) do
with {:is_owned, %Actor{}} <- User.owns_actor(user, reporter_id),
2020-01-26 21:11:16 +01:00
{:ok, _, %Report{} = report} <- API.Reports.report(args) do
{:ok, report}
else
2019-09-07 19:54:11 +02:00
{:is_owned, nil} ->
{:error, "Reporter actor id is not owned by authenticated user"}
2019-09-07 19:54:11 +02:00
_error ->
{:error, "Error while saving report"}
end
end
def create_report(_parent, _args, _resolution) do
{:error, "You need to be logged-in to create reports"}
end
@doc """
Update a report's status
"""
def update_report(
_parent,
%{report_id: report_id, moderator_id: moderator_id, status: status},
2019-09-07 19:54:11 +02:00
%{context: %{current_user: %User{role: role} = user}}
)
when is_moderator(role) do
2019-09-07 19:54:11 +02:00
with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, moderator_id),
%Report{} = report <- Mobilizon.Reports.get_report(report_id),
2020-01-26 21:11:16 +01:00
{:ok, %Report{} = report} <- API.Reports.update_report_status(actor, report, status) do
{:ok, report}
else
2019-09-07 19:54:11 +02:00
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
2019-09-07 19:54:11 +02:00
_error ->
{:error, "Error while updating report"}
end
end
def update_report(_parent, _args, _resolution) do
{:error, "You need to be logged-in and a moderator to update a report"}
end
def create_report_note(
_parent,
%{report_id: report_id, moderator_id: moderator_id, content: content},
2019-09-07 19:54:11 +02:00
%{context: %{current_user: %User{role: role} = user}}
)
when is_moderator(role) do
2019-09-07 19:54:11 +02:00
with {:is_owned, %Actor{}} <- User.owns_actor(user, moderator_id),
%Report{} = report <- Reports.get_report(report_id),
2019-09-09 00:52:49 +02:00
%Actor{} = moderator <- Actors.get_local_actor_with_preload(moderator_id),
2020-01-26 21:11:16 +01:00
{:ok, %Note{} = note} <- API.Reports.create_report_note(report, moderator, content) do
{:ok, note}
end
end
2019-09-07 19:54:11 +02:00
def delete_report_note(
_parent,
%{note_id: note_id, moderator_id: moderator_id},
%{context: %{current_user: %User{role: role} = user}}
)
when is_moderator(role) do
2019-09-07 19:54:11 +02:00
with {:is_owned, %Actor{}} <- User.owns_actor(user, moderator_id),
%Note{} = note <- Reports.get_note(note_id),
2019-09-09 00:52:49 +02:00
%Actor{} = moderator <- Actors.get_local_actor_with_preload(moderator_id),
2020-01-26 21:11:16 +01:00
{:ok, %Note{} = note} <- API.Reports.delete_report_note(note, moderator) do
{:ok, %{id: note.id}}
end
end
end