mobilizon.chapril.org-mobilizon/lib/service/activity_pub/utils.ex

# Portions of this file are derived from Pleroma:
# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social>
# SPDX-License-Identifier: AGPL-3.0-only
# Upstream: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/activity_pub/utils.ex

defmodule Mobilizon.Service.ActivityPub.Utils do
  @moduledoc """
  # Utils

  Various utils
  """

  alias Mobilizon.Repo
  alias Mobilizon.Addresses
  alias Mobilizon.Addresses.Address
  alias Mobilizon.Actors
  alias Mobilizon.Actors.Actor
  alias Mobilizon.Events.Event
  alias Mobilizon.Events.Comment
  alias Mobilizon.Media.Picture
  alias Mobilizon.Events
  alias Mobilizon.Activity
  alias Mobilizon.Reports
  alias Mobilizon.Reports.Report
  alias Mobilizon.Users
  alias Mobilizon.Service.ActivityPub.Converters
  alias Ecto.Changeset
  require Logger
  alias MobilizonWeb.Router.Helpers, as: Routes
  alias MobilizonWeb.Endpoint

  @actor_types ["Group", "Person", "Application"]

  # Some implementations send the actor URI as the actor field, others send the entire actor object,
  # so figure out what the actor's URI is based on what we have.
  def get_url(%{"id" => id}), do: id
  def get_url(id) when is_bitstring(id), do: id
  def get_url(_), do: nil

  def make_json_ld_header do
    %{
      "@context" => [
        "https://www.w3.org/ns/activitystreams",
        "https://litepub.github.io/litepub/context.jsonld",
        %{
          "sc" => "http://schema.org#",
          "Hashtag" => "as:Hashtag",
          "category" => "sc:category",
          "uuid" => "sc:identifier"
        }
      ]
    }
  end

  def make_date do
    DateTime.utc_now() |> DateTime.truncate(:second) |> DateTime.to_iso8601()
  end

  @doc """
  Enqueues an activity for federation if it's local
  """
  def maybe_federate(%Activity{local: true} = activity) do
    Logger.debug("Maybe federate an activity")

    priority =
      case activity.data["type"] do
        "Delete" -> 10
        "Create" -> 1
        _ -> 5
      end

    Mobilizon.Service.Federator.enqueue(:publish, activity, priority)
    :ok
  end

  def maybe_federate(_), do: :ok

  def remote_actors(%{data: %{"to" => to} = data}) do
    to = to ++ (data["cc"] || [])

    to
    |> Enum.map(fn url -> Actors.get_actor_by_url(url) end)
    |> Enum.map(fn {status, actor} ->
      case status do
        :ok ->
          actor

        _ ->
          nil
      end
    end)
    |> Enum.map(& &1)
    |> Enum.filter(fn actor -> actor && !is_nil(actor.domain) end)
  end

  @doc """
  Adds an id and a published data if they aren't there,
  also adds it to an included object
  """
  def lazy_put_activity_defaults(map) do
    if is_map(map["object"]) do
      object = lazy_put_object_defaults(map["object"])
      %{map | "object" => object}
    else
      map
    end
  end

  @doc """
  Adds an id and published date if they aren't there.
  """
  def lazy_put_object_defaults(map) do
    Map.put_new_lazy(map, "published", &make_date/0)
  end

  @doc """
  Inserts a full object if it is contained in an activity.
  """
  def insert_full_object(object_data)

  @doc """
  Inserts a full object if it is contained in an activity.
  """
  def insert_full_object(%{"object" => %{"type" => "Event"} = object_data, "type" => "Create"})
      when is_map(object_data) do
    with {:ok, object_data} <-
           Converters.Event.as_to_model_data(object_data),
         {:ok, %Event{} = event} <- Events.create_event(object_data) do
      {:ok, event}
    end
  end

  def insert_full_object(%{"object" => %{"type" => "Group"} = object_data, "type" => "Create"})
      when is_map(object_data) do
    with object_data <-
           Map.put(object_data, "preferred_username", object_data["preferredUsername"]),
         {:ok, %Actor{} = group} <- Actors.create_group(object_data) do
      {:ok, group}
    end
  end

  @doc """
  Inserts a full object if it is contained in an activity.
  """
  def insert_full_object(%{"object" => %{"type" => "Note"} = object_data, "type" => "Create"})
      when is_map(object_data) do
    with data <- Converters.Comment.as_to_model_data(object_data),
         {:ok, %Comment{} = comment} <- Events.create_comment(data) do
      {:ok, comment}
    else
      err ->
        Logger.error("Error while inserting a remote comment inside database")
        Logger.debug(inspect(err))
        {:error, err}
    end
  end

  @doc """
  Inserts a full object if it is contained in an activity.
  """
  def insert_full_object(%{"type" => "Flag"} = object_data)
      when is_map(object_data) do
    with data <- Converters.Flag.as_to_model_data(object_data),
         {:ok, %Report{} = report} <- Reports.create_report(data) do
      Enum.each(Users.list_moderators(), fn moderator ->
        moderator
        |> Mobilizon.Email.Admin.report(moderator, report)
        |> Mobilizon.Mailer.deliver_later()
      end)

      {:ok, report}
    else
      err ->
        Logger.error("Error while inserting a remote comment inside database")
        Logger.debug(inspect(err))
        {:error, err}
    end
  end

  def insert_full_object(_), do: {:ok, nil}

  @doc """
  Update an object
  """
  @spec update_object(struct(), map()) :: {:ok, struct()} | any()
  def update_object(object, object_data)

  def update_object(event_url, %{
        "object" => %{"type" => "Event"} = object_data,
        "type" => "Update"
      })
      when is_map(object_data) do
    with {:event_not_found, %Event{} = event} <-
           {:event_not_found, Events.get_event_by_url(event_url)},
         {:ok, object_data} <- Converters.Event.as_to_model_data(object_data),
         {:ok, %Event{} = event} <- Events.update_event(event, object_data) do
      {:ok, event}
    end
  end

  def update_object(actor_url, %{
        "object" => %{"type" => type_actor} = object_data,
        "type" => "Update"
      })
      when is_map(object_data) and type_actor in @actor_types do
    with {:ok, %Actor{} = actor} <- Actors.get_actor_by_url(actor_url),
         object_data <- Converters.Actor.as_to_model_data(object_data),
         {:ok, %Actor{} = actor} <- Actors.update_actor(actor, object_data) do
      {:ok, actor}
    end
  end

  def update_object(_, _), do: {:ok, nil}

  #### Like-related helpers

  #  @doc """
  #  Returns an existing like if a user already liked an object
  #  """
  #  def get_existing_like(actor, %{data: %{"id" => id}}) do
  #    query =
  #      from(
  #        activity in Activity,
  #        where: fragment("(?)->>'actor' = ?", activity.data, ^actor),
  #        # this is to use the index
  #        where:
  #          fragment(
  #            "coalesce((?)->'object'->>'id', (?)->>'object') = ?",
  #            activity.data,
  #            activity.data,
  #            ^id
  #          ),
  #        where: fragment("(?)->>'type' = 'Like'", activity.data)
  #      )
  #
  #    Repo.one(query)
  #  end

  @doc """
  Save picture data from %Plug.Upload{} and return AS Link data.
  """
  def make_picture_data(%Plug.Upload{} = picture) do
    case MobilizonWeb.Upload.store(picture) do
      {:ok, picture} ->
        picture

      _ ->
        nil
    end
  end

  @doc """
  Convert a picture model into an AS Link representation
  """
  # TODO: Move me to Mobilizon.Service.ActivityPub.Converters
  def make_picture_data(%Picture{file: file} = _picture) do
    %{
      "type" => "Document",
      "url" => [
        %{
          "type" => "Link",
          "mediaType" => file.content_type,
          "href" => file.url
        }
      ],
      "name" => file.name
    }
  end

  @doc """
  Save picture data from raw data and return AS Link data.
  """
  def make_picture_data(picture) when is_map(picture) do
    with {:ok, %{"url" => [%{"href" => url, "mediaType" => content_type}], "size" => size}} <-
           MobilizonWeb.Upload.store(picture.file),
         {:ok, %Picture{file: _file} = pic} <-
           Mobilizon.Media.create_picture(%{
             "file" => %{
               "url" => url,
               "name" => picture.name,
               "content_type" => content_type,
               "size" => size
             },
             "actor_id" => picture.actor_id
           }) do
      make_picture_data(pic)
    end
  end

  def make_picture_data(nil), do: nil

  @doc """
  Make an AP event object from an set of values
  """
  @spec make_event_data(
          String.t(),
          map(),
          String.t(),
          String.t(),
          map(),
          list(),
          map(),
          String.t()
        ) :: map()
  def make_event_data(
        actor,
        %{to: to, cc: cc} = _audience,
        title,
        content_html,
        picture \\ nil,
        tags \\ [],
        metadata \\ %{},
        uuid \\ nil,
        url \\ nil
      ) do
    Logger.debug("Making event data")
    uuid = uuid || Ecto.UUID.generate()

    res = %{
      "type" => "Event",
      "to" => to,
      "cc" => cc || [],
      "content" => content_html,
      "name" => title,
      "startTime" => metadata.begins_on,
      "endTime" => metadata.ends_on,
      "category" => metadata.category,
      "actor" => actor,
      "id" => url || Routes.page_url(Endpoint, :event, uuid),
      "uuid" => uuid,
      "tag" =>
        tags |> Enum.uniq() |> Enum.map(fn tag -> %{"type" => "Hashtag", "name" => "##{tag}"} end)
    }

    res =
      if is_nil(metadata.physical_address),
        do: res,
        else: Map.put(res, "location", make_address_data(metadata.physical_address))

    res =
      if is_nil(picture), do: res, else: Map.put(res, "attachment", [make_picture_data(picture)])

    if is_nil(metadata.options) do
      res
    else
      options = struct(Mobilizon.Events.EventOptions, metadata.options) |> Map.from_struct()

      Enum.reduce(options, res, fn {key, value}, acc ->
        (value && Map.put(acc, camelize(key), value)) ||
          acc
      end)
    end
  end

  def make_address_data(%Address{} = address) do
    #    res = %{
    #      "type" => "Place",
    #      "name" => address.description,
    #      "id" => address.url,
    #      "address" => %{
    #        "type" => "PostalAddress",
    #        "streetAddress" => address.street,
    #        "postalCode" => address.postal_code,
    #        "addressLocality" => address.locality,
    #        "addressRegion" => address.region,
    #        "addressCountry" => address.country
    #      }
    #    }
    #
    #    if is_nil(address.geom) do
    #      res
    #    else
    #      Map.put(res, "geo", %{
    #        "type" => "GeoCoordinates",
    #        "latitude" => address.geom.coordinates |> elem(0),
    #        "longitude" => address.geom.coordinates |> elem(1)
    #      })
    #    end
    address.url
  end

  def make_address_data(address) when is_map(address) do
    Address
    |> struct(address)
    |> make_address_data()
  end

  def make_address_data(address_url) when is_bitstring(address_url) do
    with %Address{} = address <- Addresses.get_address_by_url(address_url) do
      address.url
    end
  end

  @doc """
  Make an AP comment object from an set of values
  """
  def make_comment_data(
        actor,
        to,
        content_html,
        # attachments,
        inReplyTo \\ nil,
        tags \\ [],
        # _cw \\ nil,
        cc \\ []
      ) do
    Logger.debug("Making comment data")
    uuid = Ecto.UUID.generate()

    object = %{
      "type" => "Note",
      "to" => to,
      "cc" => cc,
      "content" => content_html,
      # "summary" => cw,
      # "attachment" => attachments,
      "actor" => actor,
      "id" => Routes.page_url(Endpoint, :comment, uuid),
      "uuid" => uuid,
      "tag" => tags |> Enum.uniq()
    }

    if inReplyTo do
      object
      |> Map.put("inReplyTo", inReplyTo)
    else
      object
    end
  end

  def make_group_data(
        actor,
        to,
        preferred_username,
        content_html,
        # attachments,
        tags \\ [],
        # _cw \\ nil,
        cc \\ []
      ) do
    uuid = Ecto.UUID.generate()

    %{
      "type" => "Group",
      "to" => to,
      "cc" => cc,
      "summary" => content_html,
      "attributedTo" => actor,
      "preferredUsername" => preferred_username,
      "id" => Actor.build_url(preferred_username, :page),
      "uuid" => uuid,
      "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
    }
  end

  #### Like-related helpers

  @doc """
  Returns an existing like if a user already liked an object
  """
  # @spec get_existing_like(Actor.t, map()) :: nil
  # def get_existing_like(%Actor{url: url} = actor, %{data: %{"id" => id}}) do
  #   nil
  # end

  # def make_like_data(%Actor{url: url} = actor, %{data: %{"id" => id}} = object, activity_id) do
  #   data = %{
  #     "type" => "Like",
  #     "actor" => url,
  #     "object" => id,
  #     "to" => [actor.followers_url, object.data["actor"]],
  #     "cc" => ["https://www.w3.org/ns/activitystreams#Public"],
  #     "context" => object.data["context"]
  #   }

  #   if activity_id, do: Map.put(data, "id", activity_id), else: data
  # end

  def update_element_in_object(property, element, object) do
    with new_data <-
           object.data
           |> Map.put("#{property}_count", length(element))
           |> Map.put("#{property}s", element),
         changeset <- Changeset.change(object, data: new_data),
         {:ok, object} <- Repo.update(changeset) do
      {:ok, object}
    end
  end

  #  def update_likes_in_object(likes, object) do
  #    update_element_in_object("like", likes, object)
  #  end
  #
  #  def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
  #    with likes <- [actor | object.data["likes"] || []] |> Enum.uniq() do
  #      update_likes_in_object(likes, object)
  #    end
  #  end
  #
  #  def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
  #    with likes <- (object.data["likes"] || []) |> List.delete(actor) do
  #      update_likes_in_object(likes, object)
  #    end
  #  end

  #### Follow-related helpers

  @doc """
  Makes a follow activity data for the given followed and follower
  """
  def make_follow_data(%Actor{url: followed_id}, %Actor{url: follower_id}, activity_id) do
    Logger.debug("Make follow data")

    data = %{
      "type" => "Follow",
      "actor" => follower_id,
      "to" => [followed_id],
      "cc" => ["https://www.w3.org/ns/activitystreams#Public"],
      "object" => followed_id
    }

    data =
      if activity_id,
        do: Map.put(data, "id", activity_id),
        else: data

    Logger.debug(inspect(data))

    data
  end

  #### Announce-related helpers

  require Logger

  @doc """
  Make announce activity data for the given actor and object
  """
  def make_announce_data(actor, object, activity_id, public \\ true)

  def make_announce_data(
        %Actor{url: actor_url, followers_url: actor_followers_url} = _actor,
        %{"id" => url, "type" => type} = _object,
        activity_id,
        public
      )
      when type in @actor_types do
    do_make_announce_data(actor_url, actor_followers_url, url, url, activity_id, public)
  end

  def make_announce_data(
        %Actor{url: actor_url, followers_url: actor_followers_url} = _actor,
        %{"id" => url, "type" => type, "actor" => object_actor_url} = _object,
        activity_id,
        public
      )
      when type in ["Note", "Event"] do
    do_make_announce_data(
      actor_url,
      actor_followers_url,
      object_actor_url,
      url,
      activity_id,
      public
    )
  end

  defp do_make_announce_data(
         actor_url,
         actor_followers_url,
         object_actor_url,
         object_url,
         activity_id,
         public
       ) do
    {to, cc} =
      if public do
        {[actor_followers_url, object_actor_url],
         ["https://www.w3.org/ns/activitystreams#Public"]}
      else
        {[actor_followers_url], []}
      end

    data = %{
      "type" => "Announce",
      "actor" => actor_url,
      "object" => object_url,
      "to" => to,
      "cc" => cc
    }

    if activity_id, do: Map.put(data, "id", activity_id), else: data
  end

  @doc """
  Make unannounce activity data for the given actor and object
  """
  def make_unannounce_data(
        %Actor{url: url} = actor,
        activity,
        activity_id
      ) do
    data = %{
      "type" => "Undo",
      "actor" => url,
      "object" => activity,
      "to" => [actor.followers_url, actor.url],
      "cc" => ["https://www.w3.org/ns/activitystreams#Public"]
    }

    if activity_id, do: Map.put(data, "id", activity_id), else: data
  end

  #### Unfollow-related helpers

  @spec make_unfollow_data(Actor.t(), Actor.t(), map(), String.t()) :: map()
  def make_unfollow_data(
        %Actor{url: follower_url},
        %Actor{url: followed_url},
        follow_activity,
        activity_id
      ) do
    data = %{
      "type" => "Undo",
      "actor" => follower_url,
      "to" => [followed_url],
      "object" => follow_activity.data
    }

    if activity_id, do: Map.put(data, "id", activity_id), else: data
  end

  #### Create-related helpers

  @doc """
  Make create activity data
  """
  @spec make_create_data(map(), map()) :: map()
  def make_create_data(params, additional \\ %{}) do
    Logger.debug("Making create data")
    Logger.debug(inspect(params))
    published = params.published || make_date()

    %{
      "type" => "Create",
      "to" => params.to |> Enum.uniq(),
      "actor" => params.actor.url,
      "object" => params.object,
      "published" => published,
      "id" => params.object["id"] <> "/activity"
    }
    |> Map.merge(additional)
  end

  #### Flag-related helpers
  @spec make_flag_data(map(), map()) :: map()
  def make_flag_data(params, additional) do
    object = [params.reported_actor_url] ++ params.comments_url

    object = if params[:event_url], do: object ++ [params.event_url], else: object

    %{
      "type" => "Flag",
      "id" => "#{MobilizonWeb.Endpoint.url()}/report/#{Ecto.UUID.generate()}",
      "actor" => params.reporter_url,
      "content" => params.content,
      "object" => object,
      "state" => "open"
    }
    |> Map.merge(additional)
  end

  def make_join_data(%Event{} = event, %Actor{} = actor) do
    %{
      "type" => "Join",
      "id" => "#{actor.url}/join/event/id",
      "actor" => actor.url,
      "object" => event.url
    }
  end

  def make_join_data(%Actor{type: :Group} = event, %Actor{} = actor) do
    %{
      "type" => "Join",
      "id" => "#{actor.url}/join/group/id",
      "actor" => actor.url,
      "object" => event.url
    }
  end

  @doc """
  Converts PEM encoded keys to a public key representation
  """
  def pem_to_public_key(pem) do
    [key_code] = :public_key.pem_decode(pem)
    key = :public_key.pem_entry_decode(key_code)

    case key do
      {:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} ->
        {:RSAPublicKey, modulus, exponent}

      {:RSAPublicKey, modulus, exponent} ->
        {:RSAPublicKey, modulus, exponent}
    end
  end

  @doc """
  Converts PEM encoded keys to a private key representation
  """
  def pem_to_private_key(pem) do
    [private_key_code] = :public_key.pem_decode(pem)
    :public_key.pem_entry_decode(private_key_code)
  end

  @doc """
  Converts PEM encoded keys to a PEM public key representation
  """
  def pem_to_public_key_pem(pem) do
    public_key = pem_to_public_key(pem)
    public_key = :public_key.pem_entry_encode(:RSAPublicKey, public_key)
    :public_key.pem_encode([public_key])
  end

  def camelize(word) when is_atom(word) do
    camelize(to_string(word))
  end

  def camelize(word) when is_bitstring(word) do
    {first, rest} = String.split_at(Macro.camelize(word), 1)
    String.downcase(first) <> rest
  end

  def underscore(word) when is_atom(word) do
    underscore(to_string(word))
  end

  def underscore(word) when is_bitstring(word) do
    Macro.underscore(word)
  end
end