defmodule Mobilizon.GraphQL.Resolvers.Participant do @moduledoc """ Handles the participation-related GraphQL calls. """ # alias Mobilizon.Conversations.ConversationParticipant alias Mobilizon.{Actors, Config, Crypto, Events} alias Mobilizon.Actors.Actor alias Mobilizon.Conversations.{Conversation, ConversationView} alias Mobilizon.Events.{Event, Participant} alias Mobilizon.GraphQL.API.Comments alias Mobilizon.GraphQL.API.Participations alias Mobilizon.Service.Export.Participants.{CSV, ODS, PDF} alias Mobilizon.Users.User alias Mobilizon.Web.Email alias Mobilizon.Web.Email.Checker require Logger import Mobilizon.Web.Gettext import Mobilizon.GraphQL.Resolvers.Event.Utils @doc """ Join an event for an regular or anonymous actor """ @spec actor_join_event(any(), map(), Absinthe.Resolution.t()) :: {:ok, Participant.t()} | {:error, String.t()} def actor_join_event( _parent, %{actor_id: actor_id, event_id: event_id} = args, %{context: %{current_user: %User{} = user}} ) do case User.owns_actor(user, actor_id) do {:is_owned, %Actor{} = actor} -> do_actor_join_event(actor, event_id, args) _ -> {:error, dgettext("errors", "Profile is not owned by authenticated user")} end end def actor_join_event( _parent, %{actor_id: actor_id, event_id: event_id} = args, _resolution ) do with {:has_event, {:ok, %Event{} = event}} <- {:has_event, Mobilizon.Events.get_event_with_preload(event_id)}, {:anonymous_participation_enabled, true} <- {:anonymous_participation_enabled, event.local == true && Config.anonymous_participation?() && event.options.anonymous_participation == true}, {:anonymous_actor_id, true} <- {:anonymous_actor_id, to_string(Config.anonymous_actor_id()) == actor_id}, {:email_required, true} <- {:email_required, Config.anonymous_participation_email_required?() && args |> Map.get(:email) |> valid_email?()}, {:confirmation_token, {confirmation_token, role}} <- {:confirmation_token, if(Config.anonymous_participation_email_confirmation_required?(), do: {Crypto.random_string(30), :not_confirmed}, else: {nil, :participant} )}, # We only federate if the participation is not to be confirmed later args <- args |> Map.put(:confirmation_token, confirmation_token) |> Map.put(:cancellation_token, Crypto.random_string(30)) |> Map.put(:role, role) |> Map.put(:local, role == :participant), {:actor_not_found, %Actor{} = actor} <- {:actor_not_found, Actors.get_actor_with_preload(actor_id)}, {:ok, %Participant{} = participant} <- do_actor_join_event(actor, event_id, args) do if Config.anonymous_participation_email_required?() && Config.anonymous_participation_email_confirmation_required?() do args |> Map.get(:email) |> Email.Participation.anonymous_participation_confirmation( participant, Map.get(args, :locale, "en") ) |> Email.Mailer.send_email() end {:ok, participant} else {:error, err} -> {:error, err} {:has_event, _} -> {:error, dgettext("errors", "Event with this ID %{id} doesn't exist", id: inspect(event_id))} {:anonymous_participation_enabled, false} -> {:error, dgettext("errors", "Anonymous participation is not enabled")} {:anonymous_actor_id, false} -> {:error, dgettext("errors", "Profile ID provided is not the anonymous profile one")} {:email_required, _} -> {:error, dgettext("errors", "A valid email is required by your instance")} {:actor_not_found, _} -> Logger.error( "The actor ID \"#{actor_id}\" provided by configuration doesn't match any actor in database" ) {:error, dgettext("errors", "Internal Error")} end end def actor_join_event(_parent, _args, _resolution) do {:error, dgettext("errors", "You need to be logged-in to join an event")} end @spec do_actor_join_event(Actor.t(), integer | String.t(), map()) :: {:ok, Participant.t()} | {:error, String.t()} defp do_actor_join_event(actor, event_id, args) do with {:has_event, {:ok, %Event{} = event}} <- {:has_event, Events.get_event_with_preload(event_id)}, {:ok, _activity, participant} <- Participations.join(event, actor, args), %Participant{} = participant <- participant |> Map.put(:event, event) |> Map.put(:actor, actor) do {:ok, participant} else {:error, :maximum_attendee_capacity_reached} -> {:error, dgettext("errors", "The event has already reached its maximum capacity")} {:has_event, _} -> {:error, dgettext("errors", "Event with this ID %{id} doesn't exist", id: inspect(event_id))} {:error, :event_not_found} -> {:error, dgettext("errors", "Event id not found")} {:error, :already_participant} -> {:error, dgettext("errors", "You are already a participant of this event")} end end @spec check_anonymous_participation(String.t(), String.t()) :: {:ok, Event.t()} | {:error, String.t()} defp check_anonymous_participation(actor_id, event_id) do cond do Config.anonymous_participation?() == false -> {:error, dgettext("errors", "Anonymous participation is not enabled")} to_string(Config.anonymous_actor_id()) != actor_id -> {:error, dgettext("errors", "The anonymous actor ID is invalid")} true -> case Mobilizon.Events.get_event_with_preload(event_id) do {:ok, %Event{} = event} -> {:ok, event} {:error, :event_not_found} -> {:error, dgettext("errors", "Event with this ID %{id} doesn't exist", id: inspect(event_id))} end end end @doc """ Leave an event for an anonymous actor """ @spec actor_leave_event(any(), map(), Absinthe.Resolution.t()) :: {:ok, map()} | {:error, String.t()} def actor_leave_event( _parent, %{actor_id: actor_id, event_id: event_id, token: token}, _resolution ) when not is_nil(token) do case check_anonymous_participation(actor_id, event_id) do {:ok, %Event{} = event} -> %Actor{} = actor = Actors.get_actor_with_preload!(actor_id) case Participations.leave(event, actor, %{local: false, cancellation_token: token}) do {:ok, _activity, %Participant{id: participant_id} = _participant} -> {:ok, %{event: %{id: event_id}, actor: %{id: actor_id}, id: participant_id}} {:error, :is_only_organizer} -> {:error, dgettext( "errors", "You can't leave event because you're the only event creator participant" )} {:error, :participant_not_found} -> {:error, dgettext("errors", "Participant not found")} {:error, _err} -> {:error, dgettext("errors", "Failed to leave the event")} end end end def actor_leave_event( _parent, %{actor_id: actor_id, event_id: event_id}, %{context: %{current_user: user}} ) do with {:is_owned, %Actor{} = actor} <- User.owns_actor(user, actor_id), {:has_event, {:ok, %Event{} = event}} <- {:has_event, Events.get_event_with_preload(event_id)}, {:ok, _activity, _participant} <- Participations.leave(event, actor) do {: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, nil} -> {:error, dgettext("errors", "Profile is not owned by authenticated user")} {:error, :is_only_organizer} -> {:error, dgettext( "errors", "You can't leave event because you're the only event creator participant" )} {:error, :participant_not_found} -> {:error, dgettext("errors", "Participant not found")} end end def actor_leave_event(_parent, _args, _resolution) do {:error, dgettext("errors", "You need to be logged-in to leave an event")} end @spec update_participation(any(), map(), Absinthe.Resolution.t()) :: {:ok, Participation.t()} | {:error, String.t() | Ecto.Changeset.t()} def update_participation( _parent, %{id: participation_id, role: new_role}, %{ context: %{ current_actor: %Actor{} = moderator_actor } } ) do # Check that participation already exists case Events.get_participant(participation_id) do %Participant{role: old_role, event_id: event_id} = participation -> if new_role != old_role do %Event{} = event = Events.get_event_with_preload!(event_id) if can_event_be_updated_by?(event, moderator_actor) do with {:ok, _activity, participation} <- Participations.update(participation, moderator_actor, new_role) do {:ok, participation} end else {:error, dgettext( "errors", "Provided profile doesn't have moderator permissions on this event" )} end else {:error, dgettext("errors", "Participant already has role %{role}", role: new_role)} end nil -> {:error, dgettext("errors", "Participant not found")} end end @spec confirm_participation_from_token(map(), map(), map()) :: {:ok, Participant.t()} | {:error, String.t()} def confirm_participation_from_token( _parent, %{confirmation_token: confirmation_token}, _context ) do with {:has_participant, %Participant{actor: actor, role: :not_confirmed, event: event} = participant} <- {:has_participant, Events.get_participant_by_confirmation_token(confirmation_token)}, {:ok, _activity, %Participant{} = participant} <- Participations.update(participant, actor, Events.get_default_participant_role(event)) do {:ok, participant} else {:has_participant, %Participant{role: :not_approved}} -> {:error, dgettext("errors", "Participation is confirmed but not approved yet by an organizer")} {:has_participant, %Participant{role: :participant}} -> {:error, dgettext("errors", "Participation is already confirmed")} {:has_participant, nil} -> {:error, dgettext("errors", "This token is invalid")} {:error, %Ecto.Changeset{} = err} -> {:error, err} end end @spec export_event_participants(any(), map(), Absinthe.Resolution.t()) :: {:ok, String.t()} def export_event_participants(_parent, %{event_id: event_id, roles: roles, format: format}, %{ context: %{ current_user: %User{locale: locale}, current_actor: %Actor{} = moderator_actor } }) do case Events.get_event_with_preload(event_id) do {:ok, %Event{} = event} -> if can_event_be_updated_by?(event, moderator_actor) do case export_format(format, event, roles, locale) do {:ok, path} -> {:ok, %{path: path, format: format}} {:error, :export_dependency_not_installed} -> {:error, dgettext( "errors", "A dependency needed to export to %{format} is not installed", format: format )} {:error, :failed_to_save_upload} -> {:error, dgettext( "errors", "An error occured while saving export", format: format )} {:error, :format_not_supported} -> {:error, dgettext( "errors", "Format not supported" )} end else {:error, dgettext( "errors", "Provided profile doesn't have moderator permissions on this event" )} end {:error, :event_not_found} -> {:error, dgettext("errors", "Event with this ID %{id} doesn't exist", id: inspect(event_id))} end end def export_event_participants(_, _, _), do: {:error, :unauthorized} def send_private_messages_to_participants( _parent, %{roles: roles, event_id: event_id, actor_id: actor_id} = args, %{ context: %{ current_user: %User{locale: _locale}, current_actor: %Actor{id: current_actor_id} } } ) do participant_actors = event_id |> Events.list_all_participants_for_event(roles) |> Enum.map(& &1.actor) mentions = participant_actors |> Enum.map(& &1.id) |> Enum.uniq() |> Enum.map(&%{actor_id: &1, event_id: event_id}) args = Map.merge(args, %{ mentions: mentions, visibility: :private }) with {:member, true} <- {:member, current_actor_id == actor_id or Actors.is_member?(current_actor_id, actor_id)}, {:ok, _activity, %Conversation{} = conversation} <- Comments.create_conversation(args) do {:ok, conversation_to_view(conversation, Actors.get_actor(actor_id))} else {:member, false} -> {:error, :unauthorized} {:error, err} -> {:error, err} end end def send_private_messages_to_participants(_parent, _args, _resolution), do: {:error, :unauthorized} defp conversation_to_view(%Conversation{} = conversation, %Actor{} = actor) do value = conversation |> Map.from_struct() |> Map.put(:actor, actor) struct(ConversationView, value) end @spec valid_email?(String.t() | nil) :: boolean defp valid_email?(email) when is_nil(email), do: false defp valid_email?(email) when is_binary(email) do email |> String.trim() |> Checker.valid?() end @spec export_format(atom(), Event.t(), list(), String.t()) :: {:ok, String.t()} | {:error, :format_not_supported | :export_dependency_not_installed | :failed_to_save_upload} defp export_format(format, event, roles, locale) do case format do :csv -> CSV.export(event, roles: roles, locale: locale) :pdf -> PDF.export(event, roles: roles, locale: locale) :ods -> ODS.export(event, roles: roles, locale: locale) _ -> {:error, :format_not_supported} end end end