No OneTemporary
Actions

Authored By

Unknown

Size

70 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/ecto_type/activity_pub/object_validators/emoji.ex b/lib/pleroma/ecto_type/activity_pub/object_validators/emoji.ex
	new file mode 100644
	index 000000000..4aacc5c88
	--- /dev/null
	+++ b/lib/pleroma/ecto_type/activity_pub/object_validators/emoji.ex
	@@ -0,0 +1,34 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.Emoji do
	+ use Ecto.Type
	+
	+ def type, do: :map
	+
	+ def cast(data) when is_map(data) do
	+ has_invalid_emoji? =
	+ Enum.find(data, fn
	+ {name, uri} when is_binary(name) and is_binary(uri) ->
	+ # based on ObjectValidators.Uri.cast()
	+ case URI.parse(uri) do
	+ %URI{host: nil} -> true
	+ %URI{host: ""} -> true
	+ %URI{scheme: scheme} when scheme in ["https", "http"] -> false
	+ _ -> true
	+ end
	+
	+ {_name, _uri} ->
	+ true
	+ end)
	+
	+ if has_invalid_emoji?, do: :error, else: {:ok, data}
	+ end
	+
	+ def cast(_data), do: :error
	+
	+ def dump(data), do: {:ok, data}
	+
	+ def load(data), do: {:ok, data}
	+end
	diff --git a/lib/pleroma/object/fetcher.ex b/lib/pleroma/object/fetcher.ex
	index 374d8704a..1de2ce6c3 100644
	--- a/lib/pleroma/object/fetcher.ex
	+++ b/lib/pleroma/object/fetcher.ex
	@@ -1,222 +1,221 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.Fetcher do
	alias Pleroma.HTTP
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.Signature
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Federator

	require Logger
	require Pleroma.Constants

	defp touch_changeset(changeset) do
	updated_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.truncate(:second)

	Ecto.Changeset.put_change(changeset, :updated_at, updated_at)
	end

	defp maybe_reinject_internal_fields(%{data: %{} = old_data}, new_data) do
	internal_fields = Map.take(old_data, Pleroma.Constants.object_internal_fields())

	Map.merge(new_data, internal_fields)
	end

	defp maybe_reinject_internal_fields(_, new_data), do: new_data

	@spec reinject_object(struct(), map()) :: {:ok, Object.t()} \| {:error, any()}
	defp reinject_object(%Object{data: %{"type" => "Question"}} = object, new_data) do
	Logger.debug("Reinjecting object #{new_data["id"]}")

	- with new_data <- Transmogrifier.fix_object(new_data),
	- data <- maybe_reinject_internal_fields(object, new_data),
	+ with data <- maybe_reinject_internal_fields(object, new_data),
	{:ok, data, _} <- ObjectValidator.validate(data, %{}),
	changeset <- Object.change(object, %{data: data}),
	changeset <- touch_changeset(changeset),
	{:ok, object} <- Repo.insert_or_update(changeset),
	{:ok, object} <- Object.set_cache(object) do
	{:ok, object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	defp reinject_object(%Object{} = object, new_data) do
	Logger.debug("Reinjecting object #{new_data["id"]}")

	with new_data <- Transmogrifier.fix_object(new_data),
	data <- maybe_reinject_internal_fields(object, new_data),
	changeset <- Object.change(object, %{data: data}),
	changeset <- touch_changeset(changeset),
	{:ok, object} <- Repo.insert_or_update(changeset),
	{:ok, object} <- Object.set_cache(object) do
	{:ok, object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	def refetch_object(%Object{data: %{"id" => id}} = object) do
	with {:local, false} <- {:local, Object.local?(object)},
	{:ok, new_data} <- fetch_and_contain_remote_object_from_id(id),
	{:ok, object} <- reinject_object(object, new_data) do
	{:ok, object}
	else
	{:local, true} -> {:ok, object}
	e -> {:error, e}
	end
	end

	# Note: will create a Create activity, which we need internally at the moment.
	def fetch_object_from_id(id, options \\ []) do
	with {_, nil} <- {:fetch_object, Object.get_cached_by_ap_id(id)},
	{_, true} <- {:allowed_depth, Federator.allowed_thread_distance?(options[:depth])},
	{_, {:ok, data}} <- {:fetch, fetch_and_contain_remote_object_from_id(id)},
	{_, nil} <- {:normalize, Object.normalize(data, false)},
	params <- prepare_activity_params(data),
	{_, :ok} <- {:containment, Containment.contain_origin(id, params)},
	{_, {:ok, activity}} <-
	{:transmogrifier, Transmogrifier.handle_incoming(params, options)},
	{_, _data, %Object{} = object} <-
	{:object, data, Object.normalize(activity, false)} do
	{:ok, object}
	else
	{:allowed_depth, false} ->
	{:error, "Max thread distance exceeded."}

	{:containment, _} ->
	{:error, "Object containment failed."}

	{:transmogrifier, {:error, {:reject, nil}}} ->
	{:reject, nil}

	{:transmogrifier, _} = e ->
	{:error, e}

	{:object, data, nil} ->
	reinject_object(%Object{}, data)

	{:normalize, object = %Object{}} ->
	{:ok, object}

	{:fetch_object, %Object{} = object} ->
	{:ok, object}

	{:fetch, {:error, error}} ->
	{:error, error}

	e ->
	e
	end
	end

	defp prepare_activity_params(data) do
	%{
	"type" => "Create",
	"to" => data["to"] \|\| [],
	"cc" => data["cc"] \|\| [],
	# Should we seriously keep this attributedTo thing?
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	}
	end

	def fetch_object_from_id!(id, options \\ []) do
	with {:ok, object} <- fetch_object_from_id(id, options) do
	object
	else
	{:error, %Tesla.Mock.Error{}} ->
	nil

	{:error, "Object has been deleted"} ->
	nil

	{:reject, reason} ->
	Logger.info("Rejected #{id} while fetching: #{inspect(reason)}")
	nil

	e ->
	Logger.error("Error while fetching #{id}: #{inspect(e)}")
	nil
	end
	end

	defp make_signature(id, date) do
	uri = URI.parse(id)

	signature =
	InternalFetchActor.get_actor()
	\|> Signature.sign(%{
	"(request-target)": "get #{uri.path}",
	host: uri.host,
	date: date
	})

	{"signature", signature}
	end

	defp sign_fetch(headers, id, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[make_signature(id, date) \| headers]
	else
	headers
	end
	end

	defp maybe_date_fetch(headers, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[{"date", date} \| headers]
	else
	headers
	end
	end

	def fetch_and_contain_remote_object_from_id(id) when is_binary(id) do
	Logger.debug("Fetching object #{id} via AP")

	date = Pleroma.Signature.signed_date()

	headers =
	[{"accept", "application/activity+json"}]
	\|> maybe_date_fetch(date)
	\|> sign_fetch(id, date)

	Logger.debug("Fetch headers: #{inspect(headers)}")

	with {:scheme, true} <- {:scheme, String.starts_with?(id, "http")},
	{:ok, %{body: body, status: code}} when code in 200..299 <- HTTP.get(id, headers),
	{:ok, data} <- Jason.decode(body),
	:ok <- Containment.contain_origin_from_id(id, data) do
	{:ok, data}
	else
	{:ok, %{status: code}} when code in [404, 410] ->
	{:error, "Object has been deleted"}

	{:scheme, _} ->
	{:error, "Unsupported URI scheme"}

	{:error, e} ->
	{:error, e}

	e ->
	{:error, e}
	end
	end

	def fetch_and_contain_remote_object_from_id(%{"id" => id}),
	do: fetch_and_contain_remote_object_from_id(id)

	def fetch_and_contain_remote_object_from_id(_id), do: {:error, "id must be a string"}
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/audio_validator.ex b/lib/pleroma/web/activity_pub/object_validators/audio_validator.ex
	index d1869f188..1a97c504a 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/audio_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/audio_validator.ex
	@@ -1,106 +1,107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AudioValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	+ alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)
	field(:content, :string)
	field(:context, :string)

	# TODO: Remove actor on objects
	field(:actor, ObjectValidators.ObjectID)

	field(:attributedTo, ObjectValidators.ObjectID)
	field(:summary, :string)
	field(:published, ObjectValidators.DateTime)
	- # TODO: Write type
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	field(:sensitive, :boolean, default: false)
	embeds_many(:attachment, AttachmentValidator)
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inReplyTo, :string)
	field(:url, ObjectValidators.Uri)
	# short identifier for PleromaFE to group statuses by context
	field(:context_id, :integer)

	field(:likes, {:array, :string}, default: [])
	field(:announcements, {:array, :string}, default: [])
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix_url(%{"url" => url} = data) when is_list(url) do
	attachment =
	Enum.find(url, fn x -> is_map(x) and String.starts_with?(x["mimeType"], "audio/") end)

	link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)

	data
	\|> Map.put("attachment", [attachment])
	\|> Map.put("url", link_element["href"])
	end

	defp fix_url(data), do: data

	defp fix(data) do
	data
	\|> CommonFixes.fix_defaults()
	\|> CommonFixes.fix_attribution()
	+ \|> Transmogrifier.fix_emoji()
	\|> fix_url()
	end

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:attachment])
	\|> cast_embed(:attachment)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Audio"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context, :attachment])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex b/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	index 91b475393..6acd4a771 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	@@ -1,129 +1,129 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.Transmogrifier, only: [fix_emoji: 1]

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:type, :string)
	field(:content, ObjectValidators.SafeText)
	field(:actor, ObjectValidators.ObjectID)
	field(:published, ObjectValidators.DateTime)
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})

	embeds_one(:attachment, AttachmentValidator)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def fix(data) do
	data
	\|> fix_emoji()
	\|> fix_attachment()
	\|> Map.put_new("actor", data["attributedTo"])
	end

	# Throws everything but the first one away
	def fix_attachment(%{"attachment" => [attachment \| _]} = data) do
	data
	\|> Map.put("attachment", attachment)
	end

	def fix_attachment(data), do: data

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, List.delete(__schema__(:fields), :attachment))
	\|> cast_embed(:attachment)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["ChatMessage"])
	\|> validate_required([:id, :actor, :to, :type, :published])
	\|> validate_content_or_attachment()
	\|> validate_length(:to, is: 1)
	\|> validate_length(:content, max: Pleroma.Config.get([:instance, :remote_limit]))
	\|> validate_local_concern()
	end

	def validate_content_or_attachment(cng) do
	attachment = get_field(cng, :attachment)

	if attachment do
	cng
	else
	cng
	\|> validate_required([:content])
	end
	end

	@doc """
	Validates the following
	- If both users are in our system
	- If at least one of the users in this ChatMessage is a local user
	- If the recipient is not blocking the actor
	- If the recipient is explicitly not accepting chat messages
	"""
	def validate_local_concern(cng) do
	with actor_ap <- get_field(cng, :actor),
	{_, %User{} = actor} <- {:find_actor, User.get_cached_by_ap_id(actor_ap)},
	{_, %User{} = recipient} <-
	{:find_recipient, User.get_cached_by_ap_id(get_field(cng, :to) \|> hd())},
	{_, false} <- {:not_accepting_chats?, recipient.accepts_chat_messages == false},
	{_, false} <- {:blocking_actor?, User.blocks?(recipient, actor)},
	{_, true} <- {:local?, Enum.any?([actor, recipient], & &1.local)} do
	cng
	else
	{:blocking_actor?, true} ->
	cng
	\|> add_error(:actor, "actor is blocked by recipient")

	{:not_accepting_chats?, true} ->
	cng
	\|> add_error(:to, "recipient does not accept chat messages")

	{:local?, false} ->
	cng
	\|> add_error(:actor, "actor and recipient are both remote")

	{:find_actor, _} ->
	cng
	\|> add_error(:actor, "can't find user")

	{:find_recipient, _} ->
	cng
	\|> add_error(:to, "can't find user")
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex b/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	index 721749de0..720213d73 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	@@ -1,22 +1,22 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes do
	alias Pleroma.Web.ActivityPub.Utils

	# based on Pleroma.Web.ActivityPub.Utils.lazy_put_objects_defaults
	def fix_defaults(data) do
	%{data: %{"id" => context}, id: context_id} =
	Utils.create_context(data["context"] \|\| data["conversation"])

	data
	- \|> Map.put_new("context", context)
	- \|> Map.put_new("context_id", context_id)
	+ \|> Map.put("context", context)
	+ \|> Map.put("context_id", context_id)
	end

	def fix_attribution(data) do
	data
	\|> Map.put_new("actor", data["attributedTo"])
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/event_validator.ex b/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	index 07e4821a4..0b4c99dc0 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	@@ -1,96 +1,97 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.EventValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	+ alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	# Extends from NoteValidator
	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)

	field(:name, :string)
	field(:summary, :string)
	field(:content, :string)

	field(:context, :string)
	# short identifier for PleromaFE to group statuses by context
	field(:context_id, :integer)

	# TODO: Remove actor on objects
	field(:actor, ObjectValidators.ObjectID)

	field(:attributedTo, ObjectValidators.ObjectID)
	field(:published, ObjectValidators.DateTime)
	- # TODO: Write type
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	field(:sensitive, :boolean, default: false)
	embeds_many(:attachment, AttachmentValidator)
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inReplyTo, ObjectValidators.ObjectID)
	field(:url, ObjectValidators.Uri)

	field(:likes, {:array, ObjectValidators.ObjectID}, default: [])
	field(:announcements, {:array, ObjectValidators.ObjectID}, default: [])
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix(data) do
	data
	\|> CommonFixes.fix_defaults()
	\|> CommonFixes.fix_attribution()
	+ \|> Transmogrifier.fix_emoji()
	end

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:attachment])
	\|> cast_embed(:attachment)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Event"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context, :context_id])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/note_validator.ex b/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	index 20e735619..ab4469a59 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	@@ -1,66 +1,73 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.NoteValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	+ alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false

	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)

	field(:name, :string)
	field(:summary, :string)
	field(:content, :string)

	field(:context, :string)
	# short identifier for PleromaFE to group statuses by context
	field(:context_id, :integer)

	field(:actor, ObjectValidators.ObjectID)
	field(:attributedTo, ObjectValidators.ObjectID)
	field(:published, ObjectValidators.DateTime)
	- # TODO: Write type
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	field(:sensitive, :boolean, default: false)
	# TODO: Write type
	field(:attachment, {:array, :map}, default: [])
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inReplyTo, ObjectValidators.ObjectID)
	field(:url, ObjectValidators.Uri)

	field(:likes, {:array, :string}, default: [])
	field(:announcements, {:array, :string}, default: [])
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	+ defp fix(data) do
	+ data
	+ \|> Transmogrifier.fix_emoji()
	+ end
	+
	def cast_data(data) do
	+ data = fix(data)
	+
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Note"])
	\|> validate_required([:id, :actor, :to, :cc, :type, :content, :context])
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/question_validator.ex b/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	index 712047424..934d3c1ea 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	@@ -1,111 +1,112 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionOptionsValidator
	+ alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	# Extends from NoteValidator
	embedded_schema do
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, ObjectValidators.Recipients, default: [])
	field(:cc, ObjectValidators.Recipients, default: [])
	field(:bto, ObjectValidators.Recipients, default: [])
	field(:bcc, ObjectValidators.Recipients, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)
	field(:content, :string)
	field(:context, :string)

	# TODO: Remove actor on objects
	field(:actor, ObjectValidators.ObjectID)

	field(:attributedTo, ObjectValidators.ObjectID)
	field(:summary, :string)
	field(:published, ObjectValidators.DateTime)
	- # TODO: Write type
	- field(:emoji, :map, default: %{})
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	field(:sensitive, :boolean, default: false)
	embeds_many(:attachment, AttachmentValidator)
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inReplyTo, ObjectValidators.ObjectID)
	field(:url, ObjectValidators.Uri)
	# short identifier for PleromaFE to group statuses by context
	field(:context_id, :integer)

	field(:likes, {:array, :string}, default: [])
	field(:announcements, {:array, :string}, default: [])

	field(:closed, ObjectValidators.DateTime)
	field(:voters, {:array, ObjectValidators.ObjectID}, default: [])
	embeds_many(:anyOf, QuestionOptionsValidator)
	embeds_many(:oneOf, QuestionOptionsValidator)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix_closed(data) do
	cond do
	is_binary(data["closed"]) -> data
	is_binary(data["endTime"]) -> Map.put(data, "closed", data["endTime"])
	true -> Map.drop(data, ["closed"])
	end
	end

	defp fix(data) do
	data
	\|> CommonFixes.fix_defaults()
	\|> CommonFixes.fix_attribution()
	+ \|> Transmogrifier.fix_emoji()
	\|> fix_closed()
	end

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:anyOf, :oneOf, :attachment])
	\|> cast_embed(:attachment)
	\|> cast_embed(:anyOf)
	\|> cast_embed(:oneOf)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Question"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context, :context_id])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_any_presence([:oneOf, :anyOf])
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 76298c4a0..0831efadc 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1060 +1,1057 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.Activity
	alias Pleroma.EarmarkRenderer
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator
	alias Pleroma.Workers.TransmogrifierWorker

	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object, options \\ []) do
	object
	\|> strip_internal_fields
	\|> fix_actor
	\|> fix_url
	\|> fix_attachments
	\|> fix_context
	\|> fix_in_reply_to(options)
	\|> fix_emoji
	\|> fix_tag
	\|> fix_content_map
	\|> fix_addressing
	\|> fix_summary
	\|> fix_type(options)
	\|> fix_content
	end

	def fix_summary(%{"summary" => nil} = object) do
	Map.put(object, "summary", "")
	end

	def fix_summary(%{"summary" => _} = object) do
	# summary is present, nothing to do
	object
	end

	def fix_summary(object), do: Map.put(object, "summary", "")

	def fix_addressing_list(map, field) do
	addrs = map[field]

	cond do
	is_list(addrs) ->
	Map.put(map, field, Enum.filter(addrs, &is_binary/1))

	is_binary(addrs) ->
	Map.put(map, field, [addrs])

	true ->
	Map.put(map, field, [])
	end
	end

	def fix_explicit_addressing(
	%{"to" => to, "cc" => cc} = object,
	explicit_mentions,
	follower_collection
	) do
	explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)

	explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)

	final_cc =
	(cc ++ explicit_cc)
	\|> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
	\|> Enum.uniq()

	object
	\|> Map.put("to", explicit_to)
	\|> Map.put("cc", final_cc)
	end

	def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object

	# if directMessage flag is set to true, leave the addressing alone
	def fix_explicit_addressing(%{"directMessage" => true} = object), do: object

	def fix_explicit_addressing(object) do
	explicit_mentions = Utils.determine_explicit_mentions(object)

	%User{follower_address: follower_collection} =
	object
	\|> Containment.get_actor()
	\|> User.get_cached_by_ap_id()

	explicit_mentions =
	explicit_mentions ++
	[
	Pleroma.Constants.as_public(),
	follower_collection
	]

	fix_explicit_addressing(object, explicit_mentions, follower_collection)
	end

	# if as:Public is addressed, then make sure the followers collection is also addressed
	# so that the activities will be delivered to local users.
	def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
	recipients = to ++ cc

	if followers_collection not in recipients do
	cond do
	Pleroma.Constants.as_public() in cc ->
	to = to ++ [followers_collection]
	Map.put(object, "to", to)

	Pleroma.Constants.as_public() in to ->
	cc = cc ++ [followers_collection]
	Map.put(object, "cc", cc)

	true ->
	object
	end
	else
	object
	end
	end

	def fix_implicit_addressing(object, _), do: object

	def fix_addressing(object) do
	{:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
	followers_collection = User.ap_followers(user)

	object
	\|> fix_addressing_list("to")
	\|> fix_addressing_list("cc")
	\|> fix_addressing_list("bto")
	\|> fix_addressing_list("bcc")
	\|> fix_explicit_addressing()
	\|> fix_implicit_addressing(followers_collection)
	end

	def fix_actor(%{"attributedTo" => actor} = object) do
	actor = Containment.get_actor(%{"actor" => actor})

	# TODO: Remove actor field for Objects
	object
	\|> Map.put("actor", actor)
	\|> Map.put("attributedTo", actor)
	end

	def fix_in_reply_to(object, options \\ [])

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
	when not is_nil(in_reply_to) do
	in_reply_to_id = prepare_in_reply_to(in_reply_to)
	object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
	depth = (options[:depth] \|\| 0) + 1

	if Federator.allowed_thread_distance?(depth) do
	with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
	%Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] \|\| in_reply_to_id)
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.drop(["conversation"])
	else
	e ->
	Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
	object
	end
	else
	object
	end
	end

	def fix_in_reply_to(object, _options), do: object

	defp prepare_in_reply_to(in_reply_to) do
	cond do
	is_bitstring(in_reply_to) ->
	in_reply_to

	is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
	in_reply_to["id"]

	is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
	Enum.at(in_reply_to, 0)

	true ->
	""
	end
	end

	def fix_context(object) do
	context = object["context"] \|\| object["conversation"] \|\| Utils.generate_context_id()

	object
	\|> Map.put("context", context)
	\|> Map.drop(["conversation"])
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	attachments =
	Enum.map(attachment, fn data ->
	url =
	cond do
	is_list(data["url"]) -> List.first(data["url"])
	is_map(data["url"]) -> data["url"]
	true -> nil
	end

	media_type =
	cond do
	is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
	MIME.valid?(data["mediaType"]) -> data["mediaType"]
	MIME.valid?(data["mimeType"]) -> data["mimeType"]
	true -> nil
	end

	href =
	cond do
	is_map(url) && is_binary(url["href"]) -> url["href"]
	is_binary(data["url"]) -> data["url"]
	is_binary(data["href"]) -> data["href"]
	true -> nil
	end

	if href do
	attachment_url =
	%{
	"href" => href,
	"type" => Map.get(url \|\| %{}, "type", "Link")
	}
	\|> Maps.put_if_present("mediaType", media_type)

	%{
	"url" => [attachment_url],
	"type" => data["type"] \|\| "Document"
	}
	\|> Maps.put_if_present("mediaType", media_type)
	\|> Maps.put_if_present("name", data["name"])
	else
	nil
	end
	end)
	\|> Enum.filter(& &1)

	Map.put(object, "attachment", attachments)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
	object
	\|> Map.put("attachment", [attachment])
	\|> fix_attachments()
	end

	def fix_attachments(object), do: object

	def fix_url(%{"url" => url} = object) when is_map(url) do
	Map.put(object, "url", url["href"])
	end

	def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
	attachment =
	Enum.find(url, fn x ->
	media_type = x["mediaType"] \|\| x["mimeType"] \|\| ""

	is_map(x) and String.starts_with?(media_type, "video/")
	end)

	link_element =
	Enum.find(url, fn x -> is_map(x) and (x["mediaType"] \|\| x["mimeType"]) == "text/html" end)

	object
	\|> Map.put("attachment", [attachment])
	\|> Map.put("url", link_element["href"])
	end

	def fix_url(%{"type" => object_type, "url" => url} = object)
	when object_type != "Video" and is_list(url) do
	first_element = Enum.at(url, 0)

	url_string =
	cond do
	is_bitstring(first_element) -> first_element
	is_map(first_element) -> first_element["href"] \|\| ""
	true -> ""
	end

	Map.put(object, "url", url_string)
	end

	def fix_url(object), do: object

	def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
	emoji =
	tags
	\|> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

	Map.put(mapping, name, data["icon"]["url"])
	end)

	- # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
	- emoji = Map.merge(object["emoji"] \|\| %{}, emoji)
	-
	Map.put(object, "emoji", emoji)
	end

	def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
	name = String.trim(tag["name"], ":")
	emoji = %{name => tag["icon"]["url"]}

	Map.put(object, "emoji", emoji)
	end

	def fix_emoji(object), do: object

	def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
	tags =
	tag
	\|> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
	\|> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)

	Map.put(object, "tag", tag ++ tags)
	end

	def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
	combined = [tag, String.slice(hashtag, 1..-1)]

	Map.put(object, "tag", combined)
	end

	def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])

	def fix_tag(object), do: object

	# content map usually only has one language so this will do for now.
	def fix_content_map(%{"contentMap" => content_map} = object) do
	content_groups = Map.to_list(content_map)
	{_, content} = Enum.at(content_groups, 0)

	Map.put(object, "content", content)
	end

	def fix_content_map(object), do: object

	def fix_type(object, options \\ [])

	def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
	when is_binary(reply_id) do
	with true <- Federator.allowed_thread_distance?(options[:depth]),
	{:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
	Map.put(object, "type", "Answer")
	else
	_ -> object
	end
	end

	def fix_type(object, _), do: object

	defp fix_content(%{"mediaType" => "text/markdown", "content" => content} = object)
	when is_binary(content) do
	html_content =
	content
	\|> Earmark.as_html!(%Earmark.Options{renderer: EarmarkRenderer})
	\|> Pleroma.HTML.filter_tags()

	Map.merge(object, %{"content" => html_content, "mediaType" => "text/html"})
	end

	defp fix_content(object), do: object

	# Reduce the object list to find the reported user.
	defp get_reported(objects) do
	Enum.reduce_while(objects, nil, fn ap_id, _ ->
	with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
	{:halt, user}
	else
	_ -> {:cont, nil}
	end
	end)
	end

	# Compatibility wrapper for Mastodon votes
	defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
	handle_incoming(data)
	end

	defp handle_create(%{"object" => object} = data, user) do
	%{
	to: data["to"],
	object: object,
	actor: user,
	context: object["context"],
	local: false,
	published: data["published"],
	additional:
	Map.take(data, [
	"cc",
	"directMessage",
	"id"
	])
	}
	\|> ActivityPub.create()
	end

	def handle_incoming(data, options \\ [])

	# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
	# with nil ID.
	def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
	with context <- data["context"] \|\| Utils.generate_context_id(),
	content <- data["content"] \|\| "",
	%User{} = actor <- User.get_cached_by_ap_id(actor),
	# Reduce the object list to find the reported user.
	%User{} = account <- get_reported(objects),
	# Remove the reported user from the object list.
	statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
	%{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content,
	additional: %{"cc" => [account.ap_id]}
	}
	\|> ActivityPub.flag()
	end
	end

	# disallow objects with bogus IDs
	def handle_incoming(%{"id" => nil}, _options), do: :error
	def handle_incoming(%{"id" => ""}, _options), do: :error
	# length of https:// = 8, should validate better, but good enough for now.
	def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
	do: :error

	# TODO: validate those with a Ecto scheme
	# - tags
	# - emoji
	def handle_incoming(
	%{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
	options
	)
	when objtype in ~w{Article Note Video Page} do
	actor = Containment.get_actor(data)

	with nil <- Activity.get_create_by_object_ap_id(object["id"]),
	{:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
	data =
	data
	\|> Map.put("object", fix_object(object, options))
	\|> Map.put("actor", actor)
	\|> fix_addressing()

	with {:ok, created_activity} <- handle_create(data, user) do
	reply_depth = (options[:depth] \|\| 0) + 1

	if Federator.allowed_thread_distance?(reply_depth) do
	for reply_id <- replies(object) do
	Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
	"id" => reply_id,
	"depth" => reply_depth
	})
	end
	end

	{:ok, created_activity}
	end
	else
	%Activity{} = activity -> {:ok, activity}
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
	options
	) do
	actor = Containment.get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
	reply_depth = (options[:depth] \|\| 0) + 1
	options = Keyword.put(options, :depth, reply_depth)
	object = fix_object(object, options)

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: nil,
	local: false,
	published: data["published"],
	additional: Map.take(data, ["cc", "id"])
	}

	ActivityPub.listen(params)
	else
	_e -> :error
	end
	end

	@misskey_reactions %{
	"like" => "👍",
	"love" => "❤️",
	"laugh" => "😆",
	"hmm" => "🤔",
	"surprise" => "😮",
	"congrats" => "🎉",
	"angry" => "💢",
	"confused" => "😥",
	"rip" => "😇",
	"pudding" => "🍮",
	"star" => "⭐"
	}

	@doc "Rewrite misskey likes into EmojiReacts"
	def handle_incoming(
	%{
	"type" => "Like",
	"_misskey_reaction" => reaction
	} = data,
	options
	) do
	data
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", @misskey_reactions[reaction] \|\| reaction)
	\|> handle_incoming(options)
	end

	def handle_incoming(
	%{"type" => "Create", "object" => %{"type" => objtype}} = data,
	_options
	)
	when objtype in ~w{Question Answer ChatMessage Audio Event} do
	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	{:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	def handle_incoming(%{"type" => type} = data, _options)
	when type in ~w{Like EmojiReact Announce} do
	with :ok <- ObjectValidator.fetch_actor_and_object(data),
	{:ok, activity, _meta} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	e -> {:error, e}
	end
	end

	def handle_incoming(
	%{"type" => type} = data,
	_options
	)
	when type in ~w{Update Block Follow Accept Reject} do
	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	{:ok, activity, _} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	def handle_incoming(
	%{"type" => "Delete"} = data,
	_options
	) do
	with {:ok, activity, _} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	{:error, {:validate_object, _}} = e ->
	# Check if we have a create activity for this
	with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
	%Activity{data: %{"actor" => actor}} <-
	Activity.create_by_object_ap_id(object_id) \|> Repo.one(),
	# We have one, insert a tombstone and retry
	{:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	handle_incoming(data)
	else
	_ -> e
	end
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "object" => followed},
	"actor" => follower,
	"id" => id
	} = _data,
	_options
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	{:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
	User.unfollow(follower, followed)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => type}
	} = data,
	_options
	)
	when type in ["Like", "EmojiReact", "Announce", "Block"] do
	with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	# For Undos that don't have the complete object attached, try to find it in our database.
	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => object
	} = activity,
	options
	)
	when is_binary(object) do
	with %Activity{data: data} <- Activity.get_by_ap_id(object) do
	activity
	\|> Map.put("object", data)
	\|> handle_incoming(options)
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Move",
	"actor" => origin_actor,
	"object" => origin_actor,
	"target" => target_actor
	},
	_options
	) do
	with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
	{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
	true <- origin_actor in target_user.also_known_as do
	ActivityPub.move(origin_user, target_user, false)
	else
	_e -> :error
	end
	end

	def handle_incoming(_, _), do: :error

	@spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} \| nil
	def get_obj_helper(id, options \\ []) do
	case Object.normalize(id, true, options) do
	%Object{} = object -> {:ok, object}
	_ -> nil
	end
	end

	@spec get_embedded_obj_helper(String.t() \| Object.t(), User.t()) :: {:ok, Object.t()} \| nil
	def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
	ap_id: ap_id
	})
	when attributed_to == ap_id do
	with {:ok, activity} <-
	handle_incoming(%{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => attributed_to,
	"object" => data
	}) do
	{:ok, Object.normalize(activity)}
	else
	_ -> get_obj_helper(object_id)
	end
	end

	def get_embedded_obj_helper(object_id, _) do
	get_obj_helper(object_id)
	end

	def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
	with false <- String.starts_with?(in_reply_to, "http"),
	{:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
	Map.put(object, "inReplyTo", replied_to_object["external_url"] \|\| in_reply_to)
	else
	_e -> object
	end
	end

	def set_reply_to_uri(obj), do: obj

	@doc """
	Serialized Mastodon-compatible `replies` collection containing _self-replies_.
	Based on Mastodon's ActivityPub::NoteSerializer#replies.
	"""
	def set_replies(obj_data) do
	replies_uris =
	with limit when limit > 0 <-
	Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
	%Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
	object
	\|> Object.self_replies()
	\|> select([o], fragment("?->>'id'", o.data))
	\|> limit(^limit)
	\|> Repo.all()
	else
	_ -> []
	end

	set_replies(obj_data, replies_uris)
	end

	defp set_replies(obj, []) do
	obj
	end

	defp set_replies(obj, replies_uris) do
	replies_collection = %{
	"type" => "Collection",
	"items" => replies_uris
	}

	Map.merge(obj, %{"replies" => replies_collection})
	end

	def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
	items
	end

	def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
	items
	end

	def replies(_), do: []

	# Prepares the object of an outgoing create activity.
	def prepare_object(object) do
	object
	\|> set_sensitive
	\|> add_hashtags
	\|> add_mention_tags
	\|> add_emoji_tags
	\|> add_attributed_to
	\|> prepare_attachments
	\|> set_conversation
	\|> set_reply_to_uri
	\|> set_replies
	\|> strip_internal_fields
	\|> strip_internal_tags
	\|> set_type
	end

	# @doc
	# """
	# internal -> Mastodon
	# """

	def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
	when activity_type in ["Create", "Listen"] do
	object =
	object_id
	\|> Object.normalize()
	\|> Map.get(:data)
	\|> prepare_object

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
	object =
	object_id
	\|> Object.normalize()

	data =
	if Visibility.is_private?(object) && object.data["actor"] == ap_id do
	data \|> Map.put("object", object \|> Map.get(:data) \|> prepare_object)
	else
	data \|> maybe_fix_object_url
	end

	data =
	data
	\|> strip_internal_fields
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	# Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
	# because of course it does.
	def prepare_outgoing(%{"type" => "Accept"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => "Reject"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => _type} = data) do
	data =
	data
	\|> strip_internal_fields
	\|> maybe_fix_object_url
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end

	def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
	with false <- String.starts_with?(object, "http"),
	{:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
	%{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
	relative_object do
	Map.put(data, "object", external_url)
	else
	{:fetch, e} ->
	Logger.error("Couldn't fetch #{object} #{inspect(e)}")
	data

	_ ->
	data
	end
	end

	def maybe_fix_object_url(data), do: data

	def add_hashtags(object) do
	tags =
	(object["tag"] \|\| [])
	\|> Enum.map(fn
	# Expand internal representation tags into AS2 tags.
	tag when is_binary(tag) ->
	%{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
	"name" => "##{tag}",
	"type" => "Hashtag"
	}

	# Do not process tags which are already AS2 tag objects.
	tag when is_map(tag) ->
	tag
	end)

	Map.put(object, "tag", tags)
	end

	# TODO These should be added on our side on insertion, it doesn't make much
	# sense to regenerate these all the time
	def add_mention_tags(object) do
	to = object["to"] \|\| []
	cc = object["cc"] \|\| []
	mentioned = User.get_users_from_set(to ++ cc, local_only: false)

	mentions = Enum.map(mentioned, &build_mention_tag/1)

	tags = object["tag"] \|\| []
	Map.put(object, "tag", tags ++ mentions)
	end

	defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
	%{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
	end

	def take_emoji_tags(%User{emoji: emoji}) do
	emoji
	\|> Map.to_list()
	\|> Enum.map(&build_emoji_tag/1)
	end

	# TODO: we should probably send mtime instead of unix epoch time for updated
	def add_emoji_tags(%{"emoji" => emoji} = object) do
	tags = object["tag"] \|\| []

	out = Enum.map(emoji, &build_emoji_tag/1)

	Map.put(object, "tag", tags ++ out)
	end

	def add_emoji_tags(object), do: object

	defp build_emoji_tag({name, url}) do
	%{
	"icon" => %{"url" => url, "type" => "Image"},
	"name" => ":" <> name <> ":",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z",
	"id" => url
	}
	end

	def set_conversation(object) do
	Map.put(object, "conversation", object["context"])
	end

	def set_sensitive(%{"sensitive" => true} = object) do
	object
	end

	def set_sensitive(object) do
	tags = object["tag"] \|\| []
	Map.put(object, "sensitive", "nsfw" in tags)
	end

	def set_type(%{"type" => "Answer"} = object) do
	Map.put(object, "type", "Note")
	end

	def set_type(object), do: object

	def add_attributed_to(object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]
	Map.put(object, "attributedTo", attributed_to)
	end

	# TODO: Revisit this
	def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

	def prepare_attachments(object) do
	attachments =
	object
	\|> Map.get("attachment", [])
	\|> Enum.map(fn data ->
	[%{"mediaType" => media_type, "href" => href} \| _] = data["url"]

	%{
	"url" => href,
	"mediaType" => media_type,
	"name" => data["name"],
	"type" => "Document"
	}
	end)

	Map.put(object, "attachment", attachments)
	end

	def strip_internal_fields(object) do
	Map.drop(object, Pleroma.Constants.object_internal_fields())
	end

	defp strip_internal_tags(%{"tag" => tags} = object) do
	tags = Enum.filter(tags, fn x -> is_map(x) end)

	Map.put(object, "tag", tags)
	end

	defp strip_internal_tags(object), do: object

	def perform(:user_upgrade, user) do
	# we pass a fake user so that the followers collection is stripped away
	old_follower_address = User.ap_followers(%User{nickname: user.nickname})

	from(
	a in Activity,
	where: ^old_follower_address in a.recipients,
	update: [
	set: [
	recipients:
	fragment(
	"array_replace(?,?,?)",
	a.recipients,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)
	\|> Repo.update_all([])
	end

	def upgrade_user_from_ap_id(ap_id) do
	with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
	{:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
	{:ok, user} <- update_user(user, data) do
	TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
	{:ok, user}
	else
	%User{} = user -> {:ok, user}
	e -> e
	end
	end

	defp update_user(user, data) do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	end

	def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
	Map.put(data, "url", url["href"])
	end

	def maybe_fix_user_url(data), do: data

	def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
	end
	diff --git a/test/web/activity_pub/object_validators/chat_validation_test.exs b/test/web/activity_pub/object_validators/chat_validation_test.exs
	index 50bf03515..16e4808e5 100644
	--- a/test/web/activity_pub/object_validators/chat_validation_test.exs
	+++ b/test/web/activity_pub/object_validators/chat_validation_test.exs
	@@ -1,211 +1,212 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.ChatValidationTest do
	use Pleroma.DataCase
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "chat message create activities" do
	test "it is invalid if the object already exists" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, activity} = CommonAPI.post_chat_message(user, recipient, "hey")
	object = Object.normalize(activity, false)

	{:ok, create_data, _} = Builder.create(user, object.data, [recipient.ap_id])

	{:error, cng} = ObjectValidator.validate(create_data, [])

	assert {:object, {"The object to create already exists", []}} in cng.errors
	end

	test "it is invalid if the object data has a different `to` or `actor` field" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, object_data, _} = Builder.chat_message(recipient, user.ap_id, "Hey")

	{:ok, create_data, _} = Builder.create(user, object_data, [recipient.ap_id])

	{:error, cng} = ObjectValidator.validate(create_data, [])

	assert {:to, {"Recipients don't match with object recipients", []}} in cng.errors
	assert {:actor, {"Actor doesn't match with object actor", []}} in cng.errors
	end
	end

	describe "chat messages" do
	setup do
	clear_config([:instance, :remote_limit])
	user = insert(:user)
	recipient = insert(:user, local: false)

	{:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey :firefox:")

	%{user: user, recipient: recipient, valid_chat_message: valid_chat_message}
	end

	test "let's through some basic html", %{user: user, recipient: recipient} do
	{:ok, valid_chat_message, _} =
	Builder.chat_message(
	user,
	recipient.ap_id,
	"hey <a href='https://example.org'>example</a> <script>alert('uguu')</script>"
	)

	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object["content"] ==
	"hey <a href=\"https://example.org\">example</a> alert('uguu')"
	end

	test "validates for a basic object we build", %{valid_chat_message: valid_chat_message} do
	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert Map.put(valid_chat_message, "attachment", nil) == object
	+ assert match?(%{"firefox" => _}, object["emoji"])
	end

	test "validates for a basic object with an attachment", %{
	valid_chat_message: valid_chat_message,
	user: user
	} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)

	valid_chat_message =
	valid_chat_message
	\|> Map.put("attachment", attachment.data)

	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object["attachment"]
	end

	test "validates for a basic object with an attachment in an array", %{
	valid_chat_message: valid_chat_message,
	user: user
	} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)

	valid_chat_message =
	valid_chat_message
	\|> Map.put("attachment", [attachment.data])

	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object["attachment"]
	end

	test "validates for a basic object with an attachment but without content", %{
	valid_chat_message: valid_chat_message,
	user: user
	} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, attachment} = ActivityPub.upload(file, actor: user.ap_id)

	valid_chat_message =
	valid_chat_message
	\|> Map.put("attachment", attachment.data)
	\|> Map.delete("content")

	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object["attachment"]
	end

	test "does not validate if the message has no content", %{
	valid_chat_message: valid_chat_message
	} do
	contentless =
	valid_chat_message
	\|> Map.delete("content")

	refute match?({:ok, _object, _meta}, ObjectValidator.validate(contentless, []))
	end

	test "does not validate if the message is longer than the remote_limit", %{
	valid_chat_message: valid_chat_message
	} do
	Pleroma.Config.put([:instance, :remote_limit], 2)
	refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
	end

	test "does not validate if the recipient is blocking the actor", %{
	valid_chat_message: valid_chat_message,
	user: user,
	recipient: recipient
	} do
	Pleroma.User.block(recipient, user)
	refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
	end

	test "does not validate if the recipient is not accepting chat messages", %{
	valid_chat_message: valid_chat_message,
	recipient: recipient
	} do
	recipient
	\|> Ecto.Changeset.change(%{accepts_chat_messages: false})
	\|> Pleroma.Repo.update!()

	refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
	end

	test "does not validate if the actor or the recipient is not in our system", %{
	valid_chat_message: valid_chat_message
	} do
	chat_message =
	valid_chat_message
	\|> Map.put("actor", "https://raymoo.com/raymoo")

	{:error, _} = ObjectValidator.validate(chat_message, [])

	chat_message =
	valid_chat_message
	\|> Map.put("to", ["https://raymoo.com/raymoo"])

	{:error, _} = ObjectValidator.validate(chat_message, [])
	end

	test "does not validate for a message with multiple recipients", %{
	valid_chat_message: valid_chat_message,
	user: user,
	recipient: recipient
	} do
	chat_message =
	valid_chat_message
	\|> Map.put("to", [user.ap_id, recipient.ap_id])

	assert {:error, _} = ObjectValidator.validate(chat_message, [])
	end

	test "does not validate if it doesn't concern local users" do
	user = insert(:user, local: false)
	recipient = insert(:user, local: false)

	{:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey")
	assert {:error, _} = ObjectValidator.validate(valid_chat_message, [])
	end
	end
	end
	diff --git a/test/web/activity_pub/transmogrifier/question_handling_test.exs b/test/web/activity_pub/transmogrifier/question_handling_test.exs
	index c82361828..74ee79543 100644
	--- a/test/web/activity_pub/transmogrifier/question_handling_test.exs
	+++ b/test/web/activity_pub/transmogrifier/question_handling_test.exs
	@@ -1,125 +1,176 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier.QuestionHandlingTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "Mastodon Question activity" do
	data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Poison.decode!()

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)

	object = Object.normalize(activity, false)

	assert object.data["url"] == "https://mastodon.sdf.org/@rinpatch/102070944809637304"

	assert object.data["closed"] == "2019-05-11T09:03:36Z"

	assert object.data["context"] == activity.data["context"]

	assert object.data["context"] ==
	"tag:mastodon.sdf.org,2019-05-10:objectId=15095122:objectType=Conversation"

	assert object.data["context_id"]

	assert object.data["anyOf"] == []

	assert Enum.sort(object.data["oneOf"]) ==
	Enum.sort([
	%{
	"name" => "25 char limit is dumb",
	"replies" => %{"totalItems" => 0, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "Dunno",
	"replies" => %{"totalItems" => 0, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "Everyone knows that!",
	"replies" => %{"totalItems" => 1, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "I can't even fit a funny",
	"replies" => %{"totalItems" => 1, "type" => "Collection"},
	"type" => "Note"
	}
	])

	user = insert(:user)

	{:ok, reply_activity} = CommonAPI.post(user, %{status: "hewwo", in_reply_to_id: activity.id})

	reply_object = Object.normalize(reply_activity, false)

	assert reply_object.data["context"] == object.data["context"]
	assert reply_object.data["context_id"] == object.data["context_id"]
	end

	test "Mastodon Question activity with HTML tags in plaintext" do
	options = [
	%{
	"type" => "Note",
	"name" => "<input type=\"date\">",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\"/>",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\" />",
	"replies" => %{"totalItems" => 1, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "<input type=\"date\"></input>",
	"replies" => %{"totalItems" => 1, "type" => "Collection"}
	}
	]

	data =
	File.read!("test/fixtures/mastodon-question-activity.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["object", "oneOf"], options)

	{:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	object = Object.normalize(activity, false)

	assert Enum.sort(object.data["oneOf"]) == Enum.sort(options)
	end

	+ test "Mastodon Question activity with custom emojis" do
	+ options = [
	+ %{
	+ "type" => "Note",
	+ "name" => ":blobcat:",
	+ "replies" => %{"totalItems" => 0, "type" => "Collection"}
	+ },
	+ %{
	+ "type" => "Note",
	+ "name" => ":blobfox:",
	+ "replies" => %{"totalItems" => 0, "type" => "Collection"}
	+ }
	+ ]
	+
	+ tag = [
	+ %{
	+ "icon" => %{
	+ "type" => "Image",
	+ "url" => "https://blob.cat/emoji/custom/blobcats/blobcat.png"
	+ },
	+ "id" => "https://blob.cat/emoji/custom/blobcats/blobcat.png",
	+ "name" => ":blobcat:",
	+ "type" => "Emoji",
	+ "updated" => "1970-01-01T00:00:00Z"
	+ },
	+ %{
	+ "icon" => %{"type" => "Image", "url" => "https://blob.cat/emoji/blobfox/blobfox.png"},
	+ "id" => "https://blob.cat/emoji/blobfox/blobfox.png",
	+ "name" => ":blobfox:",
	+ "type" => "Emoji",
	+ "updated" => "1970-01-01T00:00:00Z"
	+ }
	+ ]
	+
	+ data =
	+ File.read!("test/fixtures/mastodon-question-activity.json")
	+ \|> Poison.decode!()
	+ \|> Kernel.put_in(["object", "oneOf"], options)
	+ \|> Kernel.put_in(["object", "tag"], tag)
	+
	+ {:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(activity, false)
	+
	+ assert object.data["oneOf"] == options
	+
	+ assert object.data["emoji"] == %{
	+ "blobcat" => "https://blob.cat/emoji/custom/blobcats/blobcat.png",
	+ "blobfox" => "https://blob.cat/emoji/blobfox/blobfox.png"
	+ }
	+ end
	+
	test "returns an error if received a second time" do
	data = File.read!("test/fixtures/mastodon-question-activity.json") \|> Poison.decode!()

	assert {:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)

	assert {:error, {:validate_object, {:error, _}}} = Transmogrifier.handle_incoming(data)
	end

	test "accepts a Question with no content" do
	data =
	File.read!("test/fixtures/mastodon-question-activity.json")
	\|> Poison.decode!()
	\|> Kernel.put_in(["object", "content"], "")

	assert {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 12:21 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798979
Default Alt Text: (70 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions