debianize-mobilizon/lib/mobilizon/events/event.ex

defmodule Mobilizon.Events.Event do
  @moduledoc """
  Represents an event.
  """

  use Ecto.Schema

  import Ecto.Changeset

  alias Ecto.Changeset

  alias Mobilizon.Actors.Actor
  alias Mobilizon.{Addresses, Events, Medias, Mention}
  alias Mobilizon.Addresses.Address

  alias Mobilizon.Conversations.Conversation
  alias Mobilizon.Discussions.Comment

  alias Mobilizon.Events.{
    EventMetadata,
    EventOptions,
    EventParticipantStats,
    EventStatus,
    EventVisibility,
    JoinOptions,
    Participant,
    Session,
    Tag,
    Track
  }

  alias Mobilizon.Medias.Media
  alias Mobilizon.Storage.Repo

  alias Mobilizon.Web.Endpoint
  alias Mobilizon.Web.Router.Helpers, as: Routes

  @type t :: %__MODULE__{
          id: integer(),
          url: String.t(),
          local: boolean,
          begins_on: DateTime.t(),
          slug: String.t(),
          description: String.t(),
          ends_on: DateTime.t(),
          title: String.t(),
          status: atom(),
          draft: boolean,
          visibility: atom(),
          join_options: atom(),
          external_participation_url: String.t(),
          publish_at: DateTime.t() | nil,
          uuid: Ecto.UUID.t(),
          online_address: String.t() | nil,
          phone_address: String.t(),
          category: String.t(),
          options: EventOptions.t(),
          organizer_actor: Actor.t(),
          attributed_to: Actor.t() | nil,
          physical_address: Address.t() | nil,
          picture: Media.t() | nil,
          media: [Media.t()],
          tracks: [Track.t()],
          sessions: [Session.t()],
          mentions: [Mention.t()],
          tags: [Tag.t()],
          participants: [Actor.t()],
          contacts: [Actor.t()],
          language: String.t(),
          metadata: [EventMetadata.t()]
        }

  @update_required_attrs [:title, :begins_on, :organizer_actor_id]
  @required_attrs @update_required_attrs ++ [:url, :uuid]

  @optional_attrs [
    :slug,
    :description,
    :ends_on,
    :category,
    :status,
    :draft,
    :local,
    :visibility,
    :join_options,
    :external_participation_url,
    :publish_at,
    :online_address,
    :phone_address,
    :picture_id,
    :physical_address_id,
    :attributed_to_id,
    :language
  ]
  @attrs @required_attrs ++ @optional_attrs

  @update_attrs @update_required_attrs ++ @optional_attrs

  schema "events" do
    field(:url, :string)
    field(:local, :boolean, default: true)
    field(:begins_on, :utc_datetime)
    field(:slug, :string)
    field(:description, :string)
    field(:ends_on, :utc_datetime)
    field(:title, :string)
    field(:status, EventStatus, default: :confirmed)
    field(:draft, :boolean, default: false)
    field(:visibility, EventVisibility, default: :public)
    field(:join_options, JoinOptions, default: :free)
    field(:external_participation_url, :string)
    field(:publish_at, :utc_datetime)
    field(:uuid, Ecto.UUID, default: Ecto.UUID.generate())
    field(:online_address, :string)
    field(:phone_address, :string)
    field(:category, :string)
    field(:language, :string, default: "und")

    embeds_one(:options, EventOptions, on_replace: :delete)
    embeds_one(:participant_stats, EventParticipantStats, on_replace: :update)
    embeds_many(:metadata, EventMetadata, on_replace: :delete)
    belongs_to(:organizer_actor, Actor, foreign_key: :organizer_actor_id)
    belongs_to(:attributed_to, Actor, foreign_key: :attributed_to_id)
    belongs_to(:physical_address, Address, on_replace: :nilify)
    belongs_to(:picture, Media, on_replace: :update)
    has_many(:tracks, Track)
    has_many(:sessions, Session)
    has_many(:mentions, Mention)
    has_many(:comments, Comment)
    has_many(:conversations, Conversation)
    many_to_many(:contacts, Actor, join_through: "event_contacts", on_replace: :delete)
    many_to_many(:tags, Tag, join_through: "events_tags", on_replace: :delete)
    many_to_many(:participants, Actor, join_through: Participant)
    many_to_many(:media, Media, join_through: "events_medias", on_replace: :delete)

    timestamps(type: :utc_datetime)
  end

  @doc false
  @spec changeset(t | Ecto.Schema.t(), map) :: Changeset.t()
  def changeset(%__MODULE__{} = event, attrs) do
    attrs = Map.update(attrs, :uuid, Ecto.UUID.generate(), &(&1 || Ecto.UUID.generate()))
    attrs = Map.update(attrs, :url, Routes.page_url(Endpoint, :event, attrs.uuid), & &1)

    event
    |> cast(attrs, @attrs)
    |> common_changeset(attrs)
    |> put_creator_if_published(:create)
    |> validate_required(@required_attrs)
  end

  @doc false
  @spec update_changeset(t, map) :: Changeset.t()
  def update_changeset(%__MODULE__{} = event, attrs) do
    event
    |> cast(attrs, @update_attrs)
    |> common_changeset(attrs)
    |> put_creator_if_published(:update)
    |> validate_required(@update_required_attrs)
  end

  @spec common_changeset(Changeset.t(), map) :: Changeset.t()
  defp common_changeset(%Changeset{} = changeset, attrs) do
    changeset
    |> cast_embed(:options)
    |> cast_embed(:metadata)
    |> put_assoc(:contacts, Map.get(attrs, :contacts, []))
    |> put_assoc(:media, Map.get(attrs, :media, []))
    |> put_tags(attrs)
    |> put_address(attrs)
    |> put_picture(attrs)
    |> validate_lengths()
    |> validate_end_time()
    |> unique_constraint(:url)
  end

  @spec validate_lengths(Changeset.t()) :: Changeset.t()
  defp validate_lengths(%Changeset{} = changeset) do
    changeset
    |> validate_length(:title, min: 3, max: 200)
    |> validate_length(:online_address, min: 3, max: 2000)
    |> validate_length(:phone_address, min: 3, max: 200)
    |> validate_length(:category, min: 2, max: 100)
    |> validate_length(:slug, min: 3, max: 200)
  end

  defp validate_end_time(%Changeset{} = changeset) do
    case fetch_field(changeset, :begins_on) do
      {_, begins_on} ->
        validate_change(changeset, :ends_on, fn :ends_on, ends_on ->
          if DateTime.compare(begins_on, ends_on) == :gt,
            do: [ends_on: "ends_on cannot be set before begins_on"],
            else: []
        end)

      :error ->
        changeset
    end
  end

  @doc """
  Checks whether an event can be managed.
  """
  @spec can_be_managed_by?(t, integer | String.t()) :: boolean
  def can_be_managed_by?(%__MODULE__{organizer_actor_id: organizer_actor_id}, actor_id),
    do: organizer_actor_id == actor_id

  def can_be_managed_by?(_event, _actor), do: false

  @spec put_tags(Changeset.t(), map) :: Changeset.t()
  defp put_tags(%Changeset{} = changeset, %{tags: tags}) do
    put_assoc(changeset, :tags, Enum.map(tags, &process_tag/1))
  end

  defp put_tags(%Changeset{} = changeset, _), do: changeset

  @spec process_tag(map() | Tag.t()) :: Tag.t() | Ecto.Changeset.t()
  # We need a changeset instead of a raw struct because of slug which is generated in changeset
  defp process_tag(%{id: id} = _tag) do
    Events.get_tag(id)
  end

  defp process_tag(tag) do
    Tag.changeset(%Tag{}, tag)
  end

  # In case the provided addresses is an existing one
  @spec put_address(Changeset.t(), map) :: Changeset.t()
  defp put_address(%Changeset{} = changeset, %{physical_address: %{id: id} = _physical_address})
       when not is_nil(id) do
    case Addresses.get_address(id) do
      %Address{} = address ->
        put_assoc(changeset, :physical_address, address)

      _ ->
        cast_assoc(changeset, :physical_address)
    end
  end

  # In case it's a new address but the origin_id is an existing one
  defp put_address(%Changeset{} = changeset, %{physical_address: %{origin_id: origin_id}})
       when not is_nil(origin_id) do
    case Repo.get_by(Address, origin_id: origin_id) do
      %Address{} = address ->
        put_assoc(changeset, :physical_address, address)

      _ ->
        cast_assoc(changeset, :physical_address)
    end
  end

  # In case it's a new address without any origin_id (manual)
  defp put_address(%Changeset{} = changeset, _attrs) do
    cast_assoc(changeset, :physical_address)
  end

  # In case the provided picture is an existing one
  @spec put_picture(Changeset.t(), map) :: Changeset.t()
  defp put_picture(%Changeset{} = changeset, %{picture: %{media_id: id} = _picture}) do
    %Media{} = picture = Medias.get_media!(id)
    put_assoc(changeset, :picture, picture)
  end

  # In case it's a new picture
  defp put_picture(%Changeset{} = changeset, _attrs) do
    cast_assoc(changeset, :picture, with: &Media.changeset/2)
  end

  # Created or updated with draft parameter: don't publish
  defp put_creator_if_published(
         %Changeset{changes: %{draft: true}} = changeset,
         _action
       ) do
    put_embed(changeset, :participant_stats, %{creator: 0})
  end

  # Created with any other value: publish
  defp put_creator_if_published(
         %Changeset{} = changeset,
         :create
       ) do
    changeset
    |> put_embed(:participant_stats, %{creator: 1})
  end

  # Updated from draft false to true: publish
  defp put_creator_if_published(
         %Changeset{
           data: %{draft: false},
           changes: %{draft: true}
         } = changeset,
         :update
       ) do
    changeset
    |> put_embed(:participant_stats, %{creator: 1})
  end

  defp put_creator_if_published(%Changeset{} = changeset, _),
    do: cast_embed(changeset, :participant_stats)

  @doc """
  Whether we can show the event. Returns false if the organizer actor or group is suspended
  """
  @spec show?(t) :: boolean()
  def show?(%__MODULE__{attributed_to: %Actor{suspended: true}}), do: false
  def show?(%__MODULE__{organizer_actor: %Actor{suspended: true}}), do: false
  def show?(%__MODULE__{}), do: true
end