99 lines
3.0 KiB
Elixir
99 lines
3.0 KiB
Elixir
defmodule Mobilizon.GraphQL.API.Events do
|
|
@moduledoc """
|
|
API for Events.
|
|
"""
|
|
|
|
alias Mobilizon.Actors.Actor
|
|
alias Mobilizon.Discussions.Comment
|
|
alias Mobilizon.Events.Event
|
|
alias Mobilizon.Federation.ActivityPub.{Actions, Activity, Utils}
|
|
alias Mobilizon.GraphQL.API.Utils, as: APIUtils
|
|
|
|
@doc """
|
|
Create an event
|
|
"""
|
|
@spec create_event(map) ::
|
|
{:ok, Activity.t(), Event.t()} | {:error, atom() | Ecto.Changeset.t()}
|
|
def create_event(args) do
|
|
# For now we don't federate drafts but it will be needed if we want to edit them as groups
|
|
Actions.Create.create(:event, prepare_args(args), should_federate(args))
|
|
end
|
|
|
|
@doc """
|
|
Update an event
|
|
"""
|
|
@spec update_event(map, Event.t()) ::
|
|
{:ok, Activity.t(), Event.t()} | {:error, atom | Ecto.Changeset.t()}
|
|
def update_event(args, %Event{} = event) do
|
|
Actions.Update.update(event, prepare_args(args), should_federate(args))
|
|
end
|
|
|
|
@doc """
|
|
Trigger the deletion of an event
|
|
"""
|
|
@spec delete_event(Event.t(), Actor.t()) :: {:ok, Activity.t(), Entity.t()} | any()
|
|
def delete_event(%Event{} = event, %Actor{} = actor) do
|
|
Actions.Delete.delete(event, actor, true)
|
|
end
|
|
|
|
@spec send_private_message_to_participants(map()) ::
|
|
{:ok, Activity.t(), Comment.t()} | {:error, atom() | Ecto.Changeset.t()}
|
|
def send_private_message_to_participants(args) do
|
|
Actions.Create.create(:comment, args, true)
|
|
end
|
|
|
|
@spec prepare_args(map) :: map
|
|
defp prepare_args(args) do
|
|
organizer_actor = Map.get(args, :organizer_actor)
|
|
|
|
args
|
|
|> extract_pictures_from_event_body(organizer_actor)
|
|
|> Map.update(:picture, nil, fn picture ->
|
|
process_picture(picture, organizer_actor)
|
|
end)
|
|
end
|
|
|
|
defp process_picture(nil, _), do: nil
|
|
defp process_picture(%{media_id: _picture_id} = args, _), do: args
|
|
|
|
defp process_picture(%{media: media}, %Actor{id: actor_id}) do
|
|
# case url
|
|
if Map.has_key?(media, :url) do
|
|
%{
|
|
file: %{"url" => media.url, "name" => media.name},
|
|
actor_id: actor_id
|
|
}
|
|
|
|
# case upload
|
|
else
|
|
with uploaded when is_map(uploaded) <-
|
|
media
|
|
|> Map.get(:file)
|
|
|> Utils.make_media_data(description: Map.get(media, :name)) do
|
|
%{
|
|
file: Map.take(uploaded, [:url, :name, :content_type, :size]),
|
|
metadata: Map.take(uploaded, [:width, :height, :blurhash]),
|
|
actor_id: actor_id
|
|
}
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec extract_pictures_from_event_body(map(), Actor.t()) :: map()
|
|
defp extract_pictures_from_event_body(
|
|
%{description: description} = args,
|
|
%Actor{id: organizer_actor_id}
|
|
) do
|
|
pictures = APIUtils.extract_pictures_from_body(description, organizer_actor_id)
|
|
Map.put(args, :media, pictures)
|
|
end
|
|
|
|
defp extract_pictures_from_event_body(args, _), do: args
|
|
|
|
@spec should_federate(map()) :: boolean
|
|
defp should_federate(%{attributed_to_id: attributed_to_id}) when not is_nil(attributed_to_id),
|
|
do: true
|
|
|
|
defp should_federate(args), do: Map.get(args, :draft, false) == false
|
|
end
|