hamlab/mobilizon-frontend
2
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Refactoring of Users context

Browse Source
This commit is contained in:
miffy
2019-09-07 19:54:11 +02:00
parent d0c9974558
commit f316f0a940
14 changed files with 421 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
lib/mobilizon_web/api/groups.ex
View File

@@ -3,6 +3,7 @@ defmodule MobilizonWeb.API.Groups do
API for Events
"""
alias Mobilizon.Actors
alias Mobilizon.Actors.Actor
alias Mobilizon.Users.User
alias Mobilizon.Service.ActivityPub
alias Mobilizon.Service.ActivityPub.Utils, as: ActivityPubUtils
@@ -22,21 +23,13 @@ defmodule MobilizonWeb.API.Groups do
banner: _banner
} = args
) do
with {:is_owned, true, actor} <- User.owns_actor(user, creator_actor_id),
with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, creator_actor_id),
title <- String.trim(title),
{:existing_group, nil} <- {:existing_group, Actors.get_group_by_title(title)},
visibility <- Map.get(args, :visibility, :public),
{content_html, tags, to, cc} <-
Utils.prepare_content(actor, summary, visibility, [], nil),
group <-
ActivityPubUtils.make_group_data(
actor.url,
to,
title,
content_html,
tags,
cc
) do
group <- ActivityPubUtils.make_group_data(actor.url, to, title, content_html, tags, cc) do
ActivityPub.create(%{
to: ["https://www.w3.org/ns/activitystreams#Public"],
actor: actor,
@@ -47,7 +40,7 @@ defmodule MobilizonWeb.API.Groups do
{:existing_group, _} ->
{:error, "A group with this name already exists"}
{:is_owned, _} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
end
end

122
lib/mobilizon_web/resolvers/event.ex
View File

@@ -3,6 +3,7 @@ defmodule MobilizonWeb.Resolvers.Event do
Handles the event-related GraphQL calls
"""
alias Mobilizon.Activity
alias Mobilizon.Actors.Actor
alias Mobilizon.Addresses
alias Mobilizon.Addresses.Address
alias Mobilizon.Events
@@ -64,11 +65,8 @@ defmodule MobilizonWeb.Resolvers.Event do
# We find similar events with the same tags
# uniq_by : It's possible event_from_same_actor is inside events_from_tags
events =
(events ++
Events.find_similar_events_by_common_tags(
tags,
@number_of_related_events
))
events
|> Enum.concat(Events.find_similar_events_by_common_tags(tags, @number_of_related_events))
|> uniq_events()
# TODO: We should use tag_relations to find more appropriate events
@@ -76,8 +74,10 @@ defmodule MobilizonWeb.Resolvers.Event do
# We've considered all recommended events, so we fetch the latest events
events =
if @number_of_related_events - length(events) > 0 do
(events ++
Events.list_events(1, @number_of_related_events, :begins_on, :asc, true, true))
events
|> Enum.concat(
Events.list_events(1, @number_of_related_events, :begins_on, :asc, true, true)
)
|> uniq_events()
else
events
@@ -101,26 +101,23 @@ defmodule MobilizonWeb.Resolvers.Event do
def actor_join_event(
_parent,
%{actor_id: actor_id, event_id: event_id},
%{
context: %{
current_user: user
}
}
%{context: %{current_user: user}}
) do
with {:is_owned, true, actor} <- User.owns_actor(user, actor_id),
with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, actor_id),
{:has_event, {:ok, %Event{} = event}} <-
{:has_event, Mobilizon.Events.get_event_full(event_id)},
{:error, :participant_not_found} <- Mobilizon.Events.get_participant(event_id, actor_id),
{:ok, _activity, participant} <- MobilizonWeb.API.Participations.join(event, actor),
participant <-
Map.put(participant, :event, event)
participant
|> Map.put(:event, event)
|> Map.put(:actor, Person.proxify_pictures(actor)) do
{:ok, participant}
else
{:has_event, _} ->
{:error, "Event with this ID #{inspect(event_id)} doesn't exist"}
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
{:error, :event_not_found} ->
@@ -141,32 +138,18 @@ defmodule MobilizonWeb.Resolvers.Event do
def actor_leave_event(
_parent,
%{actor_id: actor_id, event_id: event_id},
%{
context: %{
current_user: user
}
}
%{context: %{current_user: user}}
) do
with {:is_owned, true, actor} <- User.owns_actor(user, actor_id),
with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, actor_id),
{:has_event, {:ok, %Event{} = event}} <-
{:has_event, Mobilizon.Events.get_event_full(event_id)},
{:ok, _activity, _participant} <- MobilizonWeb.API.Participations.leave(event, actor) do
{
:ok,
%{
event: %{
id: event_id
},
actor: %{
id: actor_id
}
}
}
{:ok, %{event: %{id: event_id}, actor: %{id: actor_id}}}
else
{:has_event, _} ->
{:error, "Event with this ID #{inspect(event_id)} doesn't exist"}
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
{:only_organizer, true} ->
@@ -187,31 +170,19 @@ defmodule MobilizonWeb.Resolvers.Event do
def create_event(
_parent,
%{organizer_actor_id: organizer_actor_id} = args,
%{
context: %{
current_user: user
}
} = _resolution
%{context: %{current_user: user}} = _resolution
) do
# See https://github.com/absinthe-graphql/absinthe/issues/490
with args <- Map.put(args, :options, args[:options] || %{}),
{:is_owned, true, organizer_actor} <- User.owns_actor(user, organizer_actor_id),
{:is_owned, %Actor{} = organizer_actor} <- User.owns_actor(user, organizer_actor_id),
{:ok, args} <- save_attached_picture(args),
{:ok, args} <- save_physical_address(args),
args_with_organizer <- Map.put(args, :organizer_actor, organizer_actor),
{
:ok,
%Activity{
data: %{
"object" => %{"type" => "Event"} = _object
}
},
%Event{} = event
} <-
{:ok, %Activity{data: %{"object" => %{"type" => "Event"} = _object}}, %Event{} = event} <-
MobilizonWeb.API.Events.create_event(args_with_organizer) do
{:ok, event}
else
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Organizer actor id is not owned by the user"}
end
end
@@ -226,35 +197,24 @@ defmodule MobilizonWeb.Resolvers.Event do
def update_event(
_parent,
%{event_id: event_id} = args,
%{
context: %{
current_user: user
}
} = _resolution
%{context: %{current_user: user}} = _resolution
) do
# See https://github.com/absinthe-graphql/absinthe/issues/490
with args <- Map.put(args, :options, args[:options] || %{}),
{:ok, %Event{} = event} <- Mobilizon.Events.get_event_full(event_id),
{:is_owned, true, organizer_actor} <- User.owns_actor(user, event.organizer_actor_id),
{:is_owned, %Actor{} = organizer_actor} <-
User.owns_actor(user, event.organizer_actor_id),
{:ok, args} <- save_attached_picture(args),
{:ok, args} <- save_physical_address(args),
args <- Map.put(args, :organizer_actor, organizer_actor),
{
:ok,
%Activity{
data: %{
"object" => %{"type" => "Event"} = _object
}
},
%Event{} = event
} <-
{:ok, %Activity{data: %{"object" => %{"type" => "Event"} = _object}}, %Event{} = event} <-
MobilizonWeb.API.Events.update_event(args, event) do
{:ok, event}
else
{:error, :event_not_found} ->
{:error, "Event not found"}
{:is_owned, _} ->
{:is_owned, nil} ->
{:error, "User doesn't own actor"}
end
end
@@ -268,24 +228,14 @@ defmodule MobilizonWeb.Resolvers.Event do
# However, we need to pass it's actor ID
@spec save_attached_picture(map()) :: {:ok, map()}
defp save_attached_picture(
%{
picture: %{
picture: %{file: %Plug.Upload{} = _picture} = all_pic
}
} = args
%{picture: %{picture: %{file: %Plug.Upload{} = _picture} = all_pic}} = args
) do
{:ok, Map.put(args, :picture, Map.put(all_pic, :actor_id, args.organizer_actor_id))}
end
# Otherwise if we use a previously uploaded picture we need to fetch it from database
@spec save_attached_picture(map()) :: {:ok, map()}
defp save_attached_picture(
%{
picture: %{
picture_id: picture_id
}
} = args
) do
defp save_attached_picture(%{picture: %{picture_id: picture_id}} = args) do
with %Picture{} = picture <- Mobilizon.Media.get_picture(picture_id) do
{:ok, Map.put(args, :picture, picture)}
end
@@ -295,13 +245,7 @@ defmodule MobilizonWeb.Resolvers.Event do
defp save_attached_picture(args), do: {:ok, args}
@spec save_physical_address(map()) :: {:ok, map()}
defp save_physical_address(
%{
physical_address: %{
url: physical_address_url
}
} = args
)
defp save_physical_address(%{physical_address: %{url: physical_address_url}} = args)
when not is_nil(physical_address_url) do
with %Address{} = address <- Addresses.get_address_by_url(physical_address_url),
args <- Map.put(args, :physical_address, address.url) do
@@ -326,14 +270,10 @@ defmodule MobilizonWeb.Resolvers.Event do
def delete_event(
_parent,
%{event_id: event_id, actor_id: actor_id},
%{
context: %{
current_user: user
}
}
%{context: %{current_user: user}}
) do
with {:ok, %Event{} = event} <- Mobilizon.Events.get_event(event_id),
{:is_owned, true, _} <- User.owns_actor(user, actor_id),
{:is_owned, %Actor{}} <- User.owns_actor(user, actor_id),
{:event_can_be_managed, true} <- Event.can_event_be_managed_by(event, actor_id),
event <- Mobilizon.Events.delete_event!(event) do
{:ok, %{id: event.id}}
@@ -341,7 +281,7 @@ defmodule MobilizonWeb.Resolvers.Event do
{:error, :event_not_found} ->
{:error, "Event not found"}
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
{:event_can_be_managed, false} ->

7
lib/mobilizon_web/resolvers/feed_token.ex
View File

@@ -2,10 +2,11 @@ defmodule MobilizonWeb.Resolvers.FeedToken do
@moduledoc """
Handles the feed tokens-related GraphQL calls
"""
require Logger
alias Mobilizon.Actors.Actor
alias Mobilizon.Users.User
alias Mobilizon.Events
alias Mobilizon.Events.FeedToken
require Logger
@doc """
Create an feed token for an user and a defined actor
@@ -14,11 +15,11 @@ defmodule MobilizonWeb.Resolvers.FeedToken do
def create_feed_token(_parent, %{actor_id: actor_id}, %{
context: %{current_user: %User{id: id} = user}
}) do
with {:is_owned, true, _actor} <- User.owns_actor(user, actor_id),
with {:is_owned, %Actor{}} <- User.owns_actor(user, actor_id),
{:ok, feed_token} <- Events.create_feed_token(%{"user_id" => id, "actor_id" => actor_id}) do
{:ok, feed_token}
else
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
end
end

82
lib/mobilizon_web/resolvers/group.ex
View File

@@ -40,19 +40,11 @@ defmodule MobilizonWeb.Resolvers.Group do
def create_group(
_parent,
args,
%{
context: %{
current_user: user
}
}
%{context: %{current_user: user}}
) do
with {
:ok,
%Activity{
data: %{
"object" => %{"type" => "Group"} = _object
}
},
%Activity{data: %{"object" => %{"type" => "Group"} = _object}},
%Actor{} = group
} <-
MobilizonWeb.API.Groups.create_group(
@@ -66,10 +58,7 @@ defmodule MobilizonWeb.Resolvers.Group do
banner: Map.get(args, "banner")
}
) do
{
:ok,
group
}
{:ok, group}
end
end
@@ -83,14 +72,10 @@ defmodule MobilizonWeb.Resolvers.Group do
def delete_group(
_parent,
%{group_id: group_id, actor_id: actor_id},
%{
context: %{
current_user: user
}
}
%{context: %{current_user: user}}
) do
with {:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
{:is_owned, true, _} <- User.owns_actor(user, actor_id),
{:is_owned, %Actor{}} <- User.owns_actor(user, actor_id),
{:ok, %Member{} = member} <- Member.get_member(actor_id, group.id),
{:is_admin, true} <- Member.is_administrator(member),
group <- Actors.delete_group!(group) do
@@ -99,7 +84,7 @@ defmodule MobilizonWeb.Resolvers.Group do
{:error, :group_not_found} ->
{:error, "Group not found"}
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
{:error, :member_not_found} ->
@@ -120,37 +105,24 @@ defmodule MobilizonWeb.Resolvers.Group do
def join_group(
_parent,
%{group_id: group_id, actor_id: actor_id},
%{
context: %{
current_user: user
}
}
%{context: %{current_user: user}}
) do
with {:is_owned, true, actor} <- User.owns_actor(user, actor_id),
with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, actor_id),
{:ok, %Actor{} = group} <- Actors.get_group_by_actor_id(group_id),
{:error, :member_not_found} <- Member.get_member(actor.id, group.id),
{:is_able_to_join, true} <- {:is_able_to_join, Member.can_be_joined(group)},
role <- Mobilizon.Actors.get_default_member_role(group),
{:ok, _} <-
Actors.create_member(%{
parent_id: group.id,
actor_id: actor.id,
role: role
}) do
{:ok, _} <- Actors.create_member(%{parent_id: group.id, actor_id: actor.id, role: role}) do
{
:ok,
%{
parent:
group
|> Person.proxify_pictures(),
actor:
actor
|> Person.proxify_pictures(),
parent: Person.proxify_pictures(group),
actor: Person.proxify_pictures(actor),
role: role
}
}
else
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
{:error, :group_not_found} ->
@@ -174,31 +146,17 @@ defmodule MobilizonWeb.Resolvers.Group do
def leave_group(
_parent,
%{group_id: group_id, actor_id: actor_id},
%{
context: %{
current_user: user
}
}
%{context: %{current_user: user}}
) do
with {:is_owned, true, actor} <- User.owns_actor(user, actor_id),
with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, actor_id),
{:ok, %Member{} = member} <- Member.get_member(actor.id, group_id),
{:only_administrator, false} <-
{:only_administrator, check_that_member_is_not_last_administrator(group_id, actor_id)},
{:ok, _} <-
Mobilizon.Actors.delete_member(member) do
{
:ok,
%{
parent: %{
id: group_id
},
actor: %{
id: actor_id
}
}
}
{:ok, %{parent: %{id: group_id}, actor: %{id: actor_id}}}
else
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
{:error, :member_not_found} ->
@@ -219,13 +177,7 @@ defmodule MobilizonWeb.Resolvers.Group do
@spec check_that_member_is_not_last_administrator(integer(), integer()) :: boolean()
defp check_that_member_is_not_last_administrator(group_id, actor_id) do
case Member.list_administrator_members_for_group(group_id) do
[
%Member{
actor: %Actor{
id: member_actor_id
}
}
] ->
[%Member{actor: %Actor{id: member_actor_id}}] ->
actor_id == member_actor_id
_ ->

36
lib/mobilizon_web/resolvers/person.ex
View File

@@ -50,9 +50,7 @@ defmodule MobilizonWeb.Resolvers.Person do
def create_person(
_parent,
%{preferred_username: _preferred_username} = args,
%{
context: %{current_user: user}
} = _resolution
%{context: %{current_user: user}} = _resolution
) do
args = Map.put(args, :user_id, user.id)
@@ -75,17 +73,13 @@ defmodule MobilizonWeb.Resolvers.Person do
def update_person(
_parent,
%{preferred_username: preferred_username} = args,
%{
context: %{
current_user: user
}
} = _resolution
%{context: %{current_user: user}} = _resolution
) do
args = Map.put(args, :user_id, user.id)
with {:find_actor, %Actor{} = actor} <-
{:find_actor, Actors.get_actor_by_name(preferred_username)},
{:is_owned, true, _} <- User.owns_actor(user, actor.id),
{:is_owned, %Actor{}} <- User.owns_actor(user, actor.id),
args <- save_attached_pictures(args),
{:ok, actor} <- Actors.update_actor(actor, args) do
{:ok, actor}
@@ -93,7 +87,7 @@ defmodule MobilizonWeb.Resolvers.Person do
{:find_actor, nil} ->
{:error, "Actor not found"}
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor is not owned by authenticated user"}
end
end
@@ -108,15 +102,11 @@ defmodule MobilizonWeb.Resolvers.Person do
def delete_person(
_parent,
%{preferred_username: preferred_username} = _args,
%{
context: %{
current_user: user
}
} = _resolution
%{context: %{current_user: user}} = _resolution
) do
with {:find_actor, %Actor{} = actor} <-
{:find_actor, Actors.get_actor_by_name(preferred_username)},
{:is_owned, true, _} <- User.owns_actor(user, actor.id),
{:is_owned, %Actor{}} <- User.owns_actor(user, actor.id),
{:last_identity, false} <- {:last_identity, last_identity?(user)},
{:last_admin, false} <- {:last_admin, last_admin_of_a_group?(actor.id)},
{:ok, actor} <- Actors.delete_actor(actor) do
@@ -131,7 +121,7 @@ defmodule MobilizonWeb.Resolvers.Person do
{:last_admin, true} ->
{:error, "Cannot remove the last administrator of a group"}
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor is not owned by authenticated user"}
end
end
@@ -184,14 +174,12 @@ defmodule MobilizonWeb.Resolvers.Person do
@doc """
Returns the list of events this person is going to
"""
def person_going_to_events(%Actor{id: actor_id}, _args, %{
context: %{current_user: user}
}) do
with {:is_owned, true, actor} <- User.owns_actor(user, actor_id),
def person_going_to_events(%Actor{id: actor_id}, _args, %{context: %{current_user: user}}) do
with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, actor_id),
events <- Events.list_event_participations_for_actor(actor) do
{:ok, events}
else
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
end
end
@@ -199,9 +187,7 @@ defmodule MobilizonWeb.Resolvers.Person do
@doc """
Returns the list of events this person is going to
"""
def person_going_to_events(_parent, %{}, %{
context: %{current_user: user}
}) do
def person_going_to_events(_parent, %{}, %{context: %{current_user: user}}) do
with %Actor{} = actor <- Users.get_actor_for_user(user),
events <- Events.list_event_participations_for_actor(actor) do
{:ok, events}

37
lib/mobilizon_web/resolvers/picture.ex
View File

@@ -2,6 +2,7 @@ defmodule MobilizonWeb.Resolvers.Picture do
@moduledoc """
Handles the picture-related GraphQL calls
"""
alias Mobilizon.Actors.Actor
alias Mobilizon.Media
alias Mobilizon.Media.Picture
alias Mobilizon.Users.User
@@ -10,9 +11,7 @@ defmodule MobilizonWeb.Resolvers.Picture do
Get picture for an event's pic
"""
def picture(%{picture_id: picture_id} = _parent, _args, _resolution) do
with {:ok, picture} <- do_fetch_picture(picture_id) do
{:ok, picture}
end
with {:ok, picture} <- do_fetch_picture(picture_id), do: {:ok, picture}
end
@doc """
@@ -20,15 +19,9 @@ defmodule MobilizonWeb.Resolvers.Picture do
See MobilizonWeb.Resolvers.Event.create_event/3
"""
def picture(%{picture: picture} = _parent, _args, _resolution) do
{:ok, picture}
end
def picture(%{picture: picture} = _parent, _args, _resolution), do: {:ok, picture}
def picture(_parent, %{id: picture_id}, _resolution), do: do_fetch_picture(picture_id)
def picture(_parent, _args, _resolution) do
{:ok, nil}
end
def picture(_parent, _args, _resolution), do: {:ok, nil}
@spec do_fetch_picture(nil) :: {:error, nil}
defp do_fetch_picture(nil), do: {:error, nil}
@@ -36,7 +29,7 @@ defmodule MobilizonWeb.Resolvers.Picture do
@spec do_fetch_picture(String.t()) :: {:ok, Picture.t()} | {:error, :not_found}
defp do_fetch_picture(picture_id) do
case Media.get_picture(picture_id) do
%Picture{id: id, file: file} = _pic ->
%Picture{id: id, file: file} ->
{:ok,
%{
name: file.name,
@@ -46,18 +39,18 @@ defmodule MobilizonWeb.Resolvers.Picture do
size: file.size
}}
_err ->
_error ->
{:error, "Picture with ID #{picture_id} was not found"}
end
end
@spec upload_picture(map(), map(), map()) :: {:ok, Picture.t()} | {:error, any()}
def upload_picture(_parent, %{file: %Plug.Upload{} = file, actor_id: actor_id} = args, %{
context: %{
current_user: user
}
}) do
with {:is_owned, true, _actor} <- User.owns_actor(user, actor_id),
def upload_picture(
_parent,
%{file: %Plug.Upload{} = file, actor_id: actor_id} = args,
%{context: %{current_user: user}}
) do
with {:is_owned, %Actor{}} <- User.owns_actor(user, actor_id),
{:ok, %{"url" => [%{"href" => url, "mediaType" => content_type}], "size" => size}} <-
MobilizonWeb.Upload.store(file),
args <-
@@ -76,11 +69,11 @@ defmodule MobilizonWeb.Resolvers.Picture do
size: picture.file.size
}}
else
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
err ->
{:error, err}
error ->
{:error, error}
end
end

45
lib/mobilizon_web/resolvers/report.ex
View File

@@ -10,9 +10,11 @@ defmodule MobilizonWeb.Resolvers.Report do
alias MobilizonWeb.API.Reports, as: ReportsAPI
import Mobilizon.Users.Guards
def list_reports(_parent, %{page: page, limit: limit}, %{
context: %{current_user: %User{role: role}}
})
def list_reports(
_parent,
%{page: page, limit: limit},
%{context: %{current_user: %User{role: role}}}
)
when is_moderator(role) do
{:ok, Mobilizon.Reports.list_reports(page, limit)}
end
@@ -21,9 +23,7 @@ defmodule MobilizonWeb.Resolvers.Report do
{:error, "You need to be logged-in and a moderator to list reports"}
end
def get_report(_parent, %{id: id}, %{
context: %{current_user: %User{role: role}}
})
def get_report(_parent, %{id: id}, %{context: %{current_user: %User{role: role}}})
when is_moderator(role) do
{:ok, Mobilizon.Reports.get_report(id)}
end
@@ -40,14 +40,14 @@ defmodule MobilizonWeb.Resolvers.Report do
%{reporter_actor_id: reporter_actor_id} = args,
%{context: %{current_user: user}} = _resolution
) do
with {:is_owned, true, _} <- User.owns_actor(user, reporter_actor_id),
with {:is_owned, %Actor{}} <- User.owns_actor(user, reporter_actor_id),
{:ok, _, %Report{} = report} <- ReportsAPI.report(args) do
{:ok, report}
else
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Reporter actor id is not owned by authenticated user"}
_err ->
_error ->
{:error, "Error while saving report"}
end
end
@@ -62,22 +62,19 @@ defmodule MobilizonWeb.Resolvers.Report do
def update_report(
_parent,
%{report_id: report_id, moderator_id: moderator_id, status: status},
%{
context: %{current_user: %User{role: role} = user}
}
%{context: %{current_user: %User{role: role} = user}}
)
when is_moderator(role) do
with {:is_owned, true, _} <- User.owns_actor(user, moderator_id),
%Actor{} = actor <- Actors.get_actor!(moderator_id),
with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, moderator_id),
%Report{} = report <- Mobilizon.Reports.get_report(report_id),
{:ok, %Report{} = report} <-
MobilizonWeb.API.Reports.update_report_status(actor, report, status) do
{:ok, report}
else
{:is_owned, false} ->
{:is_owned, nil} ->
{:error, "Actor id is not owned by authenticated user"}
_err ->
_error ->
{:error, "Error while updating report"}
end
end
@@ -89,12 +86,10 @@ defmodule MobilizonWeb.Resolvers.Report do
def create_report_note(
_parent,
%{report_id: report_id, moderator_id: moderator_id, content: content},
%{
context: %{current_user: %User{role: role} = user}
}
%{context: %{current_user: %User{role: role} = user}}
)
when is_moderator(role) do
with {:is_owned, true, _} <- User.owns_actor(user, moderator_id),
with {:is_owned, %Actor{}} <- User.owns_actor(user, moderator_id),
%Report{} = report <- Reports.get_report(report_id),
%Actor{} = moderator <- Actors.get_local_actor_with_everything(moderator_id),
{:ok, %Note{} = note} <-
@@ -103,11 +98,13 @@ defmodule MobilizonWeb.Resolvers.Report do
end
end
def delete_report_note(_parent, %{note_id: note_id, moderator_id: moderator_id}, %{
context: %{current_user: %User{role: role} = user}
})
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
with {:is_owned, true, _} <- User.owns_actor(user, moderator_id),
with {:is_owned, %Actor{}} <- User.owns_actor(user, moderator_id),
%Note{} = note <- Reports.get_note(note_id),
%Actor{} = moderator <- Actors.get_local_actor_with_everything(moderator_id),
{:ok, %Note{} = note} <-

10
lib/mobilizon_web/resolvers/user.ex
View File

@@ -118,8 +118,8 @@ defmodule MobilizonWeb.Resolvers.User do
{:registrations_open, false} ->
{:error, "Registrations are not enabled"}
err ->
err
error ->
error
end
end
@@ -139,9 +139,9 @@ defmodule MobilizonWeb.Resolvers.User do
user: Map.put(user, :default_actor, actor)
}}
else
err ->
error ->
Logger.info("Unable to validate user with token #{token}")
Logger.debug(inspect(err))
Logger.debug(inspect(error))
{:error, "Unable to validate user"}
end
end
@@ -213,7 +213,7 @@ defmodule MobilizonWeb.Resolvers.User do
{:user_actor, _} ->
{:error, :actor_not_from_user}
_err ->
_error ->
{:error, :unable_to_change_default_actor}
end
end