263 lines
7.8 KiB
Elixir
263 lines
7.8 KiB
Elixir
defmodule Mobilizon.Service.ActivityPub.Converter.Event do
|
|
@moduledoc """
|
|
Event converter.
|
|
|
|
This module allows to convert events from ActivityStream format to our own
|
|
internal one, and back.
|
|
"""
|
|
|
|
alias Mobilizon.{Actors, Addresses, Events, Media}
|
|
alias Mobilizon.Actors.Actor
|
|
alias Mobilizon.Addresses.Address
|
|
alias Mobilizon.Events.Event, as: EventModel
|
|
alias Mobilizon.Events.{EventOptions, Tag}
|
|
alias Mobilizon.Media.Picture
|
|
alias Mobilizon.Service.ActivityPub.{Converter, Convertible, Utils}
|
|
alias Mobilizon.Service.ActivityPub.Converter.Address, as: AddressConverter
|
|
alias Mobilizon.Service.ActivityPub.Converter.Picture, as: PictureConverter
|
|
|
|
require Logger
|
|
|
|
@behaviour Converter
|
|
|
|
defimpl Convertible, for: EventModel do
|
|
alias Mobilizon.Service.ActivityPub.Converter.Event, as: EventConverter
|
|
|
|
defdelegate model_to_as(event), to: EventConverter
|
|
end
|
|
|
|
@doc """
|
|
Converts an AP object data to our internal data structure.
|
|
"""
|
|
@impl Converter
|
|
@spec as_to_model_data(map) :: map
|
|
def as_to_model_data(object) do
|
|
Logger.debug("event as_to_model_data")
|
|
Logger.debug(inspect(object))
|
|
|
|
with {:actor, {:ok, %Actor{id: actor_id}}} <-
|
|
{:actor, Actors.get_actor_by_url(object["actor"])},
|
|
{:address, address_id} <-
|
|
{:address, get_address(object["location"])},
|
|
{:tags, tags} <- {:tags, fetch_tags(object["tag"])},
|
|
{:visibility, visibility} <- {:visibility, get_visibility(object)},
|
|
{:options, options} <- {:options, get_options(object)} do
|
|
picture_id =
|
|
with true <- Map.has_key?(object, "attachment") && length(object["attachment"]) > 0,
|
|
%Picture{id: picture_id} <-
|
|
Media.get_picture_by_url(
|
|
object["attachment"]
|
|
|> hd
|
|
|> Map.get("url")
|
|
|> hd
|
|
|> Map.get("href")
|
|
) do
|
|
picture_id
|
|
else
|
|
_ -> nil
|
|
end
|
|
|
|
entity = %{
|
|
"title" => object["name"],
|
|
"description" => object["content"],
|
|
"organizer_actor_id" => actor_id,
|
|
"picture_id" => picture_id,
|
|
"begins_on" => object["startTime"],
|
|
"ends_on" => object["endTime"],
|
|
"category" => object["category"],
|
|
"visibility" => visibility,
|
|
"join_options" => object["joinOptions"],
|
|
"status" => object["status"],
|
|
"online_address" => object["onlineAddress"],
|
|
"phone_address" => object["phoneAddress"],
|
|
"url" => object["id"],
|
|
"uuid" => object["uuid"],
|
|
"tags" => tags,
|
|
"physical_address_id" => address_id
|
|
}
|
|
|
|
{:ok, Map.put(entity, "options", options)}
|
|
else
|
|
error ->
|
|
{:error, error}
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Convert an event struct to an ActivityStream representation.
|
|
"""
|
|
@impl Converter
|
|
@spec model_to_as(EventModel.t()) :: map
|
|
def model_to_as(%EventModel{} = event) do
|
|
to =
|
|
if event.visibility == :public,
|
|
do: ["https://www.w3.org/ns/activitystreams#Public"],
|
|
else: [event.organizer_actor.followers_url]
|
|
|
|
res = %{
|
|
"type" => "Event",
|
|
"to" => to,
|
|
"cc" => [],
|
|
"attributedTo" => event.organizer_actor.url,
|
|
"name" => event.title,
|
|
"actor" => event.organizer_actor.url,
|
|
"uuid" => event.uuid,
|
|
"category" => event.category,
|
|
"content" => event.description,
|
|
"publish_at" => (event.publish_at || event.inserted_at) |> date_to_string(),
|
|
"updated_at" => event.updated_at |> date_to_string(),
|
|
"mediaType" => "text/html",
|
|
"startTime" => event.begins_on |> date_to_string(),
|
|
"endTime" => event.ends_on |> date_to_string(),
|
|
"tag" => event.tags |> build_tags(),
|
|
"id" => event.url,
|
|
"url" => event.url
|
|
}
|
|
|
|
res =
|
|
if is_nil(event.physical_address),
|
|
do: res,
|
|
else: Map.put(res, "location", AddressConverter.model_to_as(event.physical_address))
|
|
|
|
if is_nil(event.picture),
|
|
do: res,
|
|
else: Map.put(res, "attachment", [PictureConverter.model_to_as(event.picture)])
|
|
end
|
|
|
|
# Get only elements that we have in EventOptions
|
|
@spec get_options(map) :: map
|
|
defp get_options(object) do
|
|
keys =
|
|
EventOptions
|
|
|> struct
|
|
|> Map.keys()
|
|
|> List.delete(:__struct__)
|
|
|> Enum.map(&Utils.camelize/1)
|
|
|
|
Enum.reduce(object, %{}, fn {key, value}, acc ->
|
|
(value && key in keys && Map.put(acc, Utils.underscore(key), value)) ||
|
|
acc
|
|
end)
|
|
end
|
|
|
|
@spec get_address(map | binary | nil) :: integer | nil
|
|
defp get_address(address_url) when is_bitstring(address_url) do
|
|
get_address(%{"id" => address_url})
|
|
end
|
|
|
|
defp get_address(%{"id" => url} = map) when is_map(map) and is_binary(url) do
|
|
Logger.debug("Address with an URL, let's check against our own database")
|
|
|
|
case Addresses.get_address_by_url(url) do
|
|
%Address{id: address_id} ->
|
|
address_id
|
|
|
|
_ ->
|
|
Logger.debug("not in our database, let's try to create it")
|
|
map = Map.put(map, "url", map["id"])
|
|
do_get_address(map)
|
|
end
|
|
end
|
|
|
|
defp get_address(map) when is_map(map) do
|
|
do_get_address(map)
|
|
end
|
|
|
|
defp get_address(nil), do: nil
|
|
|
|
@spec do_get_address(map) :: integer | nil
|
|
defp do_get_address(map) do
|
|
map = Mobilizon.Service.ActivityPub.Converter.Address.as_to_model_data(map)
|
|
|
|
case Addresses.create_address(map) do
|
|
{:ok, %Address{id: address_id}} ->
|
|
address_id
|
|
|
|
_ ->
|
|
nil
|
|
end
|
|
end
|
|
|
|
@spec fetch_tags([String.t()]) :: [String.t()]
|
|
defp fetch_tags(tags) do
|
|
Logger.debug("fetching tags")
|
|
|
|
Enum.reduce(tags, [], fn tag, acc ->
|
|
with true <- tag["type"] == "Hashtag",
|
|
{:ok, %Tag{} = tag} <- Events.get_or_create_tag(tag) do
|
|
acc ++ [tag]
|
|
else
|
|
_err ->
|
|
acc
|
|
end
|
|
end)
|
|
end
|
|
|
|
@spec build_tags([String.t()]) :: String.t()
|
|
defp build_tags(tags) do
|
|
Enum.map(tags, fn %Tag{} = tag ->
|
|
%{
|
|
"href" => MobilizonWeb.Endpoint.url() <> "/tags/#{tag.slug}",
|
|
"name" => "##{tag.title}",
|
|
"type" => "Hashtag"
|
|
}
|
|
end)
|
|
end
|
|
|
|
@ap_public "https://www.w3.org/ns/activitystreams#Public"
|
|
|
|
defp get_visibility(object) do
|
|
cond do
|
|
@ap_public in object["to"] -> :public
|
|
@ap_public in object["cc"] -> :unlisted
|
|
true -> :private
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Convert an event struct to an ActivityStream representation
|
|
"""
|
|
@impl Converter
|
|
@spec model_to_as(EventModel.t()) :: map()
|
|
def model_to_as(%EventModel{} = event) do
|
|
to =
|
|
if event.visibility == :public,
|
|
do: ["https://www.w3.org/ns/activitystreams#Public"],
|
|
else: [event.organizer_actor.followers_url]
|
|
|
|
res = %{
|
|
"type" => "Event",
|
|
"to" => to,
|
|
"cc" => [],
|
|
"attributedTo" => event.organizer_actor.url,
|
|
"name" => event.title,
|
|
"actor" => event.organizer_actor.url,
|
|
"uuid" => event.uuid,
|
|
"category" => event.category,
|
|
"content" => event.description,
|
|
"publish_at" => (event.publish_at || event.inserted_at) |> date_to_string(),
|
|
"updated_at" => event.updated_at |> date_to_string(),
|
|
"mediaType" => "text/html",
|
|
"startTime" => event.begins_on |> date_to_string(),
|
|
"endTime" => event.ends_on |> date_to_string(),
|
|
"joinOptions" => to_string(event.join_options),
|
|
"tag" => event.tags |> build_tags(),
|
|
"id" => event.url,
|
|
"url" => event.url
|
|
}
|
|
|
|
res =
|
|
if is_nil(event.physical_address),
|
|
do: res,
|
|
else: Map.put(res, "location", AddressConverter.model_to_as(event.physical_address))
|
|
|
|
if is_nil(event.picture),
|
|
do: res,
|
|
else: Map.put(res, "attachment", [Utils.make_picture_data(event.picture)])
|
|
end
|
|
|
|
@spec date_to_string(DateTime.t() | nil) :: String.t()
|
|
defp date_to_string(nil), do: nil
|
|
defp date_to_string(%DateTime{} = date), do: DateTime.to_iso8601(date)
|
|
end
|