No OneTemporary
Actions

Authored By

Unknown

Size

86 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 462aa57a6..d8cc8d24f 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1451 +1,1451 @@
	# 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.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.ActivityExpiration
	alias Pleroma.Config
	alias Pleroma.Constants
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.Filter
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.Upload
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.WebFinger
	alias Pleroma.Workers.BackgroundWorker

	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	import Pleroma.Web.ActivityPub.Visibility

	require Logger
	require Pleroma.Constants

	defp get_recipients(%{"type" => "Create"} = data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	actor = Map.get(data, "actor", [])
	recipients = [to, cc, bcc, [actor]] \|> Enum.concat() \|> Enum.uniq()
	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	recipients = Enum.concat([to, cc, bcc])
	{recipients, to, cc}
	end

	defp check_actor_is_active(nil), do: true

	defp check_actor_is_active(actor) when is_binary(actor) do
	case User.get_cached_by_ap_id(actor) do
	%User{deactivated: deactivated} -> not deactivated
	_ -> false
	end
	end

	defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
	limit = Config.get([:instance, :remote_limit])
	String.length(content) <= limit
	end

	defp check_remote_limit(_), do: true

	defp increase_note_count_if_public(actor, object) do
	if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
	end

	def decrease_note_count_if_public(actor, object) do
	if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
	end

	defp increase_replies_count_if_reply(%{
	"object" => %{"inReplyTo" => reply_ap_id} = object,
	"type" => "Create"
	}) do
	if is_public?(object) do
	Object.increase_replies_count(reply_ap_id)
	end
	end

	defp increase_replies_count_if_reply(_create_data), do: :noop

	defp increase_poll_votes_if_vote(%{
	"object" => %{"inReplyTo" => reply_ap_id, "name" => name},
	"type" => "Create",
	"actor" => actor
	}) do
	Object.increase_vote_count(reply_ap_id, name, actor)
	end

	defp increase_poll_votes_if_vote(_create_data), do: :noop

	- @object_types ["ChatMessage", "Question"]
	+ @object_types ["ChatMessage", "Question", "Answer"]
	@spec persist(map(), keyword()) :: {:ok, Activity.t() \| Object.t()}
	def persist(%{"type" => type} = object, meta) when type in @object_types do
	with {:ok, object} <- Object.create(object) do
	{:ok, object, meta}
	end
	end

	def persist(object, meta) do
	with local <- Keyword.fetch!(meta, :local),
	{recipients, _, _} <- get_recipients(object),
	{:ok, activity} <-
	Repo.insert(%Activity{
	data: object,
	local: local,
	recipients: recipients,
	actor: object["actor"]
	}) do
	{:ok, activity, meta}
	end
	end

	@spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map, fake),
	true <- bypass_actor_check \|\| check_actor_is_active(map["actor"]),
	{_, true} <- {:remote_limit_error, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	{recipients, _, _} = get_recipients(map),
	{:fake, false, map, recipients} <- {:fake, fake, map, recipients},
	{:containment, :ok} <- {:containment, Containment.contain_child(map)},
	{:ok, map, object} <- insert_full_object(map) do
	{:ok, activity} =
	%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients
	}
	\|> Repo.insert()
	\|> maybe_create_activity_expiration()

	# Splice in the child object if we have one.
	activity = Maps.put_if_present(activity, :object, object)

	BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})

	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

	{:fake, true, map, recipients} ->
	activity = %Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients,
	id: "pleroma:fakeid"
	}

	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	{:ok, activity}

	error ->
	{:error, error}
	end
	end

	def notify_and_stream(activity) do
	Notification.create_notifications(activity)

	conversation = create_or_bump_conversation(activity, activity.actor)
	participations = get_participations(conversation)
	stream_out(activity)
	stream_out_participations(participations)
	end

	defp maybe_create_activity_expiration({:ok, %{data: %{"expires_at" => expires_at}} = activity}) do
	with {:ok, _} <- ActivityExpiration.create(activity, expires_at) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(result), do: result

	defp create_or_bump_conversation(activity, actor) do
	with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
	%User{} = user <- User.get_cached_by_ap_id(actor) do
	Participation.mark_as_read(user, conversation)
	{:ok, conversation}
	end
	end

	defp get_participations({:ok, conversation}) do
	conversation
	\|> Repo.preload(:participations, force: true)
	\|> Map.get(:participations)
	end

	defp get_participations(_), do: []

	def stream_out_participations(participations) do
	participations =
	participations
	\|> Repo.preload(:user)

	Streamer.stream("participation", participations)
	end

	def stream_out_participations(%Object{data: %{"context" => context}}, user) do
	with %Conversation{} = conversation <- Conversation.get_for_ap_id(context) do
	conversation = Repo.preload(conversation, :participations)

	last_activity_id =
	fetch_latest_direct_activity_id_for_context(conversation.ap_id, %{
	user: user,
	blocking_user: user
	})

	if last_activity_id do
	stream_out_participations(conversation.participations)
	end
	end
	end

	def stream_out_participations(_, _), do: :noop

	def stream_out(%Activity{data: %{"type" => data_type}} = activity)
	when data_type in ["Create", "Announce", "Delete"] do
	activity
	\|> Topics.get_activity_topics()
	\|> Streamer.stream(activity)
	end

	def stream_out(_activity) do
	:noop
	end

	@spec create(map(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def create(params, fake \\ false) do
	with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
	result
	end
	end

	defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]
	quick_insert? = Config.get([:env]) == :benchmark

	create_data =
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	_ <- increase_poll_votes_if_vote(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

	{:fake, true, activity} ->
	{:ok, activity}

	{:error, message} ->
	Repo.rollback(message)
	end
	end

	@spec listen(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def listen(%{to: to, actor: actor, context: context, object: object} = params) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	listen_data =
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(listen_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec accept(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def accept(params) do
	accept_or_reject("Accept", params)
	end

	@spec reject(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def reject(params) do
	accept_or_reject("Reject", params)
	end

	@spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} \| {:error, any()}
	defp accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
	local = Map.get(params, :local, true)
	activity_id = Map.get(params, :activity_id, nil)

	data =
	%{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
	\|> Maps.put_if_present("id", activity_id)

	with {:ok, activity} <- insert(data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec unfollow(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| nil \| {:error, any()}
	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
	result
	end
	end

	defp do_unfollow(follower, followed, activity_id, local) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	nil -> nil
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec flag(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def flag(
	%{
	actor: actor,
	context: _context,
	account: account,
	statuses: statuses,
	content: content
	} = params
	) do
	# only accept false as false value
	local = !(params[:local] == false)
	forward = !(params[:forward] == false)

	additional = params[:additional] \|\| %{}

	additional =
	if forward do
	Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
	else
	Map.merge(additional, %{"to" => [], "cc" => []})
	end

	with flag_data <- make_flag_data(params, additional),
	{:ok, activity} <- insert(flag_data, local),
	{:ok, stripped_activity} <- strip_report_status_data(activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(stripped_activity) do
	User.all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	end
	end

	@spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def move(%User{} = origin, %User{} = target, local \\ true) do
	params = %{
	"type" => "Move",
	"actor" => origin.ap_id,
	"object" => origin.ap_id,
	"target" => target.ap_id
	}

	with true <- origin.ap_id in target.also_known_as,
	{:ok, activity} <- insert(params, local),
	_ <- notify_and_stream(activity) do
	maybe_federate(activity)

	BackgroundWorker.enqueue("move_following", %{
	"origin_id" => origin.id,
	"target_id" => target.id
	})

	{:ok, activity}
	else
	false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
	err -> err
	end
	end

	def fetch_activities_for_context_query(context, opts) do
	public = [Constants.as_public()]

	recipients =
	if opts[:user],
	do: [opts[:user].ap_id \| User.following(opts[:user])] ++ public,
	else: public

	from(activity in Activity)
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> restrict_blocked(opts)
	\|> restrict_recipients(recipients, opts[:user])
	\|> restrict_filtered(opts)
	\|> where(
	[activity],
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	)
	)
	\|> exclude_poll_votes(opts)
	\|> exclude_id(opts)
	\|> order_by([activity], desc: activity.id)
	end

	@spec fetch_activities_for_context(String.t(), keyword() \| map()) :: [Activity.t()]
	def fetch_activities_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(opts)
	\|> Repo.all()
	end

	@spec fetch_latest_direct_activity_id_for_context(String.t(), keyword() \| map()) ::
	FlakeId.Ecto.CompatType.t() \| nil
	def fetch_latest_direct_activity_id_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(Map.merge(%{skip_preload: true}, opts))
	\|> restrict_visibility(%{visibility: "direct"})
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

	@spec fetch_public_or_unlisted_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_or_unlisted_activities(opts \\ %{}, pagination \\ :keyset) do
	opts = Map.delete(opts, :user)

	[Constants.as_public()]
	\|> fetch_activities_query(opts)
	\|> restrict_unlisted(opts)
	\|> Pagination.fetch_paginated(opts, pagination)
	end

	@spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	opts
	\|> Map.put(:restrict_unlisted, true)
	\|> fetch_public_or_unlisted_activities(pagination)
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not restrict visibility to #{visibility}")
	end
	end

	defp restrict_visibility(query, %{visibility: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ?",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility not in [nil \| @valid_visibilities] do
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end

	defp exclude_visibility(query, _visibility), do: query

	defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
	do: query

	defp restrict_thread_visibility(query, %{user: %User{skip_thread_containment: true}}, _),
	do: query

	defp restrict_thread_visibility(query, %{user: %User{ap_id: ap_id}}, _) do
	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
	)
	end

	defp restrict_thread_visibility(query, _, _), do: query

	def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params)
	\|> Enum.reverse()
	end

	def fetch_user_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)
	\|> Map.put(:pinned_activity_ids, user.pinned_activities)

	params =
	if User.blocks?(reading_user, user) do
	params
	else
	params
	\|> Map.put(:blocking_user, reading_user)
	\|> Map.put(:muting_user, reading_user)
	end

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params)
	\|> Enum.reverse()
	end

	def fetch_statuses(reading_user, params) do
	params = Map.put(params, :type, ["Create", "Announce"])

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, :offset)
	\|> Enum.reverse()
	end

	defp user_activities_recipients(%{godmode: true}), do: []

	defp user_activities_recipients(%{reading_user: reading_user}) do
	if reading_user do
	[Constants.as_public(), reading_user.ap_id \| User.following(reading_user)]
	else
	[Constants.as_public()]
	end
	end

	defp restrict_announce_object_actor(_query, %{announce_filtering_user: _, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_announce_object_actor(query, %{announce_filtering_user: %{ap_id: actor}}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'type' != ? or ?->>'actor' != ?",
	activity.data,
	"Announce",
	object.data,
	^actor
	)
	)
	end

	defp restrict_announce_object_actor(query, _), do: query

	defp restrict_since(query, %{since_id: ""}), do: query

	defp restrict_since(query, %{since_id: since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	defp restrict_tag_reject(_query, %{tag_reject: _tag_reject, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag_reject(query, %{tag_reject: [_ \| _] = tag_reject}) do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'tag' \\?\| (?)", object.data, ^tag_reject)
	)
	end

	defp restrict_tag_reject(query, _), do: query

	defp restrict_tag_all(_query, %{tag_all: _tag_all, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag_all(query, %{tag_all: [_ \| _] = tag_all}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
	)
	end

	defp restrict_tag_all(query, _), do: query

	defp restrict_tag(_query, %{tag: _tag, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag(query, %{tag: tag}) when is_list(tag) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?\| (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, %{tag: tag}) when is_binary(tag) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, _), do: query

	defp restrict_recipients(query, [], _user), do: query

	defp restrict_recipients(query, recipients, nil) do
	from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
	end

	defp restrict_recipients(query, recipients, user) do
	from(
	activity in query,
	where: fragment("? && ?", ^recipients, activity.recipients),
	or_where: activity.actor == ^user.ap_id
	)
	end

	defp restrict_local(query, %{local_only: true}) do
	from(activity in query, where: activity.local == true)
	end

	defp restrict_local(query, _), do: query

	defp restrict_actor(query, %{actor_id: actor_id}) do
	from(activity in query, where: activity.actor == ^actor_id)
	end

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{type: type}) when is_binary(type) do
	from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
	end

	defp restrict_type(query, %{type: type}) do
	from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
	end

	defp restrict_type(query, _), do: query

	defp restrict_state(query, %{state: state}) do
	from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
	end

	defp restrict_state(query, _), do: query

	defp restrict_favorited_by(query, %{favorited_by: ap_id}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(_query, %{only_media: _val, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_media(query, %{only_media: true}) do
	from(
	[activity, object] in query,
	where: fragment("(?)->>'type' = ?", activity.data, "Create"),
	where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

	defp restrict_replies(query, %{exclude_replies: true}) do
	from(
	[_activity, object] in query,
	where: fragment("?->>'inReplyTo' is null", object.data)
	)
	end

	defp restrict_replies(query, %{
	reply_filtering_user: user,
	reply_visibility: "self"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'inReplyTo' is null OR ? = ANY(?)",
	object.data,
	^user.ap_id,
	activity.recipients
	)
	)
	end

	defp restrict_replies(query, %{
	reply_filtering_user: user,
	reply_visibility: "following"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
	object.data,
	^[user.ap_id \| User.get_cached_user_friends_ap_ids(user)],
	activity.recipients,
	activity.actor,
	activity.actor,
	^user.ap_id
	)
	)
	end

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{exclude_reblogs: true}) do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{with_muted: true}), do: query

	defp restrict_muted(query, %{muting_user: %User{} = user} = opts) do
	mutes = opts[:muted_users_ap_ids] \|\| User.muted_users_ap_ids(user)

	query =
	from([activity] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
	where: fragment("not (?->'to' \\?\| ?)", activity.data, ^mutes)
	)

	unless opts[:skip_preload] do
	from([thread_mute: tm] in query, where: is_nil(tm.user_id))
	else
	query
	end
	end

	defp restrict_muted(query, _), do: query

	defp restrict_blocked(query, %{blocking_user: %User{} = user} = opts) do
	blocked_ap_ids = opts[:blocked_users_ap_ids] \|\| User.blocked_users_ap_ids(user)
	domain_blocks = user.domain_blocks \|\| []

	following_ap_ids = User.get_friends_ap_ids(user)

	query =
	if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)

	from(
	[activity, object: o] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
	where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
	where:
	fragment(
	"recipients_contain_blocked_domains(?, ?) = false",
	activity.recipients,
	^domain_blocks
	),
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocked_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
	activity.actor,
	^domain_blocks,
	activity.actor,
	^following_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
	o.data,
	^domain_blocks,
	o.data,
	^following_ap_ids
	)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_unlisted(query, %{restrict_unlisted: true}) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^[Constants.as_public()]
	)
	)
	end

	defp restrict_unlisted(query, _), do: query

	defp restrict_pinned(query, %{pinned: true, pinned_activity_ids: ids}) do
	from(activity in query, where: activity.id in ^ids)
	end

	defp restrict_pinned(query, _), do: query

	defp restrict_muted_reblogs(query, %{muting_user: %User{} = user} = opts) do
	muted_reblogs = opts[:reblog_muted_users_ap_ids] \|\| User.reblog_muted_users_ap_ids(user)

	from(
	activity in query,
	where:
	fragment(
	"not ( ?->>'type' = 'Announce' and ? = ANY(?))",
	activity.data,
	activity.actor,
	^muted_reblogs
	)
	)
	end

	defp restrict_muted_reblogs(query, _), do: query

	defp restrict_instance(query, %{instance: instance}) do
	users =
	from(
	u in User,
	select: u.ap_id,
	where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
	)
	\|> Repo.all()

	from(activity in query, where: activity.actor in ^users)
	end

	defp restrict_instance(query, _), do: query

	defp restrict_filtered(query, %{user: %User{} = user}) do
	case Filter.compose_regex(user) do
	nil ->
	query

	regex ->
	from([activity, object] in query,
	where:
	fragment("not(?->>'content' ~* ?)", object.data, ^regex) or
	activity.actor == ^user.ap_id
	)
	end
	end

	defp restrict_filtered(query, %{blocking_user: %User{} = user}) do
	restrict_filtered(query, %{user: user})
	end

	defp restrict_filtered(query, _), do: query

	defp exclude_poll_votes(query, %{include_poll_votes: true}), do: query

	defp exclude_poll_votes(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "Answer")
	)
	else
	query
	end
	end

	defp exclude_chat_messages(query, %{include_chat_messages: true}), do: query

	defp exclude_chat_messages(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "ChatMessage")
	)
	else
	query
	end
	end

	defp exclude_invisible_actors(query, %{invisible_actors: true}), do: query

	defp exclude_invisible_actors(query, _opts) do
	invisible_ap_ids =
	User.Query.build(%{invisible: true, select: [:ap_id]})
	\|> Repo.all()
	\|> Enum.map(fn %{ap_id: ap_id} -> ap_id end)

	from([activity] in query, where: activity.actor not in ^invisible_ap_ids)
	end

	defp exclude_id(query, %{exclude_id: id}) when is_binary(id) do
	from(activity in query, where: activity.id != ^id)
	end

	defp exclude_id(query, _), do: query

	defp maybe_preload_objects(query, %{skip_preload: true}), do: query

	defp maybe_preload_objects(query, _) do
	query
	\|> Activity.with_preloaded_object()
	end

	defp maybe_preload_bookmarks(query, %{skip_preload: true}), do: query

	defp maybe_preload_bookmarks(query, opts) do
	query
	\|> Activity.with_preloaded_bookmark(opts[:user])
	end

	defp maybe_preload_report_notes(query, %{preload_report_notes: true}) do
	query
	\|> Activity.with_preloaded_report_notes()
	end

	defp maybe_preload_report_notes(query, _), do: query

	defp maybe_set_thread_muted_field(query, %{skip_preload: true}), do: query

	defp maybe_set_thread_muted_field(query, opts) do
	query
	\|> Activity.with_set_thread_muted_field(opts[:muting_user] \|\| opts[:user])
	end

	defp maybe_order(query, %{order: :desc}) do
	query
	\|> order_by(desc: :id)
	end

	defp maybe_order(query, %{order: :asc}) do
	query
	\|> order_by(asc: :id)
	end

	defp maybe_order(query, _), do: query

	defp fetch_activities_query_ap_ids_ops(opts) do
	source_user = opts[:muting_user]
	ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []

	ap_id_relationships =
	if opts[:blocking_user] && opts[:blocking_user] == source_user do
	[:block \| ap_id_relationships]
	else
	ap_id_relationships
	end

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)

	restrict_blocked_opts = Map.merge(%{blocked_users_ap_ids: preloaded_ap_ids[:block]}, opts)
	restrict_muted_opts = Map.merge(%{muted_users_ap_ids: preloaded_ap_ids[:mute]}, opts)

	restrict_muted_reblogs_opts =
	Map.merge(%{reblog_muted_users_ap_ids: preloaded_ap_ids[:reblog_mute]}, opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
	end

	def fetch_activities_query(recipients, opts \\ %{}) do
	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
	fetch_activities_query_ap_ids_ops(opts)

	config = %{
	skip_thread_containment: Config.get([:instance, :skip_thread_containment])
	}

	Activity
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_preload_report_notes(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> maybe_order(opts)
	\|> restrict_recipients(recipients, opts[:user])
	\|> restrict_replies(opts)
	\|> restrict_tag(opts)
	\|> restrict_tag_reject(opts)
	\|> restrict_tag_all(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_state(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(restrict_blocked_opts)
	\|> restrict_muted(restrict_muted_opts)
	\|> restrict_filtered(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_thread_visibility(opts, config)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(restrict_muted_reblogs_opts)
	\|> restrict_instance(opts)
	\|> restrict_announce_object_actor(opts)
	\|> restrict_filtered(opts)
	\|> Activity.restrict_deactivated_users()
	\|> exclude_poll_votes(opts)
	\|> exclude_chat_messages(opts)
	\|> exclude_invisible_actors(opts)
	\|> exclude_visibility(opts)
	end

	def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
	list_memberships = Pleroma.List.memberships(opts[:user])

	fetch_activities_query(recipients ++ list_memberships, opts)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	\|> maybe_update_cc(list_memberships, opts[:user])
	end

	@doc """
	Fetch favorites activities of user with order by sort adds to favorites
	"""
	@spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
	def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Like")
	\|> Activity.with_joined_object()
	\|> Object.with_joined_activity()
	\|> select([like, object, activity], %{activity \| object: object, pagination_id: like.id})
	\|> order_by([like, _, _], desc_nulls_last: like.id)
	\|> Pagination.fetch_paginated(
	Map.merge(params, %{skip_order: true}),
	pagination
	)
	end

	defp maybe_update_cc(activities, [_ \| _] = list_memberships, %User{ap_id: user_ap_id}) do
	Enum.map(activities, fn
	%{data: %{"bcc" => [_ \| _] = bcc}} = activity ->
	if Enum.any?(bcc, &(&1 in list_memberships)) do
	update_in(activity.data["cc"], &[user_ap_id \| &1])
	else
	activity
	end

	activity ->
	activity
	end)
	end

	defp maybe_update_cc(activities, _, _), do: activities

	defp fetch_activities_bounded_query(query, recipients, recipients_with_public) do
	from(activity in query,
	where:
	fragment("? && ?", activity.recipients, ^recipients) or
	(fragment("? && ?", activity.recipients, ^recipients_with_public) and
	^Constants.as_public() in activity.recipients)
	)
	end

	def fetch_activities_bounded(
	recipients,
	recipients_with_public,
	opts \\ %{},
	pagination \\ :keyset
	) do
	fetch_activities_query([], opts)
	\|> fetch_activities_bounded_query(recipients, recipients_with_public)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	end

	@spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} \| {:error, any()}
	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data = Maps.put_if_present(data, "actor", opts[:actor])

	Repo.insert(%Object{data: obj_data})
	end
	end

	@spec get_actor_url(any()) :: binary() \| nil
	defp get_actor_url(url) when is_binary(url), do: url
	defp get_actor_url(%{"href" => href}) when is_binary(href), do: href

	defp get_actor_url(url) when is_list(url) do
	url
	\|> List.first()
	\|> get_actor_url()
	end

	defp get_actor_url(_url), do: nil

	defp object_to_user_data(data) do
	avatar =
	data["icon"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["icon"]["url"]}]
	}

	banner =
	data["image"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["image"]["url"]}]
	}

	fields =
	data
	\|> Map.get("attachment", [])
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)

	emojis =
	data
	\|> Map.get("tag", [])
	\|> Enum.filter(fn
	%{"type" => "Emoji"} -> true
	_ -> false
	end)
	\|> Map.new(fn %{"icon" => %{"url" => url}, "name" => name} ->
	{String.trim(name, ":"), url}
	end)

	locked = data["manuallyApprovesFollowers"] \|\| false
	capabilities = data["capabilities"] \|\| %{}
	accepts_chat_messages = capabilities["acceptsChatMessages"]
	data = Transmogrifier.maybe_fix_user_object(data)
	discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

	public_key =
	if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
	data["publicKey"]["publicKeyPem"]
	else
	nil
	end

	shared_inbox =
	if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
	data["endpoints"]["sharedInbox"]
	else
	nil
	end

	user_data = %{
	ap_id: data["id"],
	uri: get_actor_url(data["url"]),
	ap_enabled: true,
	banner: banner,
	fields: fields,
	emoji: emojis,
	locked: locked,
	discoverable: discoverable,
	invisible: invisible,
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	bio: data["summary"],
	actor_type: actor_type,
	also_known_as: Map.get(data, "alsoKnownAs", []),
	public_key: public_key,
	inbox: data["inbox"],
	shared_inbox: shared_inbox,
	accepts_chat_messages: accepts_chat_messages
	}

	# nickname can be nil because of virtual actors
	if data["preferredUsername"] do
	Map.put(
	user_data,
	:nickname,
	"#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
	)
	else
	Map.put(user_data, :nickname, nil)
	end
	end

	def fetch_follow_information_for_user(user) do
	with {:ok, following_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
	{:ok, hide_follows} <- collection_private(following_data),
	{:ok, followers_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
	{:ok, hide_followers} <- collection_private(followers_data) do
	{:ok,
	%{
	hide_follows: hide_follows,
	follower_count: normalize_counter(followers_data["totalItems"]),
	following_count: normalize_counter(following_data["totalItems"]),
	hide_followers: hide_followers
	}}
	else
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp normalize_counter(counter) when is_integer(counter), do: counter
	defp normalize_counter(_), do: 0

	def maybe_update_follow_information(user_data) do
	with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
	{_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
	{_, true} <-
	{:collections_available,
	!!(user_data[:following_address] && user_data[:follower_address])},
	{:ok, info} <-
	fetch_follow_information_for_user(user_data) do
	info = Map.merge(user_data[:info] \|\| %{}, info)

	user_data
	\|> Map.put(:info, info)
	else
	{:user_type_check, false} ->
	user_data

	{:collections_available, false} ->
	user_data

	{:enabled, false} ->
	user_data

	e ->
	Logger.error(
	"Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
	)

	user_data
	end
	end

	defp collection_private(%{"first" => %{"type" => type}})
	when type in ["CollectionPage", "OrderedCollectionPage"],
	do: {:ok, false}

	defp collection_private(%{"first" => first}) do
	with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
	Fetcher.fetch_and_contain_remote_object_from_id(first) do
	{:ok, false}
	else
	{:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp collection_private(_data), do: {:ok, true}

	def user_data_from_user_object(data) do
	with {:ok, data} <- MRF.filter(data) do
	{:ok, object_to_user_data(data)}
	else
	e -> {:error, e}
	end
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data) do
	{:ok, maybe_update_follow_information(data)}
	else
	{:error, "Object has been deleted" = e} ->
	Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}

	{:error, e} ->
	Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}
	end
	end

	def maybe_handle_clashing_nickname(data) do
	nickname = data[:nickname]

	with %User{} = old_user <- User.get_by_nickname(nickname),
	{_, false} <- {:ap_id_comparison, data[:ap_id] == old_user.ap_id} do
	Logger.info(
	"Found an old user for #{nickname}, the old ap id is #{old_user.ap_id}, new one is #{
	data[:ap_id]
	}, renaming."
	)

	old_user
	\|> User.remote_user_changeset(%{nickname: "#{old_user.id}.#{old_user.nickname}"})
	\|> User.update_and_set_cache()
	else
	{:ap_id_comparison, true} ->
	Logger.info(
	"Found an old user for #{nickname}, but the ap id #{data[:ap_id]} is the same as the new user. Race condition? Not changing anything."
	)

	_ ->
	nil
	end
	end

	def make_user_from_ap_id(ap_id) do
	user = User.get_cached_by_ap_id(ap_id)

	if user && !User.ap_enabled?(user) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	if user do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	else
	maybe_handle_clashing_nickname(data)

	data
	\|> User.remote_user_changeset()
	\|> Repo.insert()
	\|> User.set_cache()
	end
	end
	end
	end

	def make_user_from_nickname(nickname) do
	with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
	make_user_from_ap_id(ap_id)
	else
	_e -> {:error, "No AP id in WebFinger"}
	end
	end

	# filter out broken threads
	defp contain_broken_threads(%Activity{} = activity, %User{} = user) do
	entire_thread_visible_for_user?(activity, user)
	end

	# do post-processing on a specific activity
	def contain_activity(%Activity{} = activity, %User{} = user) do
	contain_broken_threads(activity, user)
	end

	def fetch_direct_messages_query do
	Activity
	\|> restrict_type(%{type: "Create"})
	\|> restrict_visibility(%{visibility: "direct"})
	\|> order_by([activity], asc: activity.id)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index 5cc66d7bd..c89311187 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,210 +1,226 @@
	# 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.ObjectValidator do
	@moduledoc """
	This module is responsible for validating an object (which can be an activity)
	and checking if it is both well formed and also compatible with our view of
	the system.
	"""

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.AnswerValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateQuestionValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator

	@spec validate(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	def validate(object, meta)

	def validate(%{"type" => "Follow"} = object, meta) do
	with {:ok, object} <-
	object
	\|> FollowValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Block"} = block_activity, meta) do
	with {:ok, block_activity} <-
	block_activity
	\|> BlockValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	block_activity = stringify_keys(block_activity)
	outgoing_blocks = Pleroma.Config.get([:activitypub, :outgoing_blocks])

	meta =
	if !outgoing_blocks do
	Keyword.put(meta, :do_not_federate, true)
	else
	meta
	end

	{:ok, block_activity, meta}
	end
	end

	def validate(%{"type" => "Update"} = update_activity, meta) do
	with {:ok, update_activity} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	update_activity = stringify_keys(update_activity)
	{:ok, update_activity, meta}
	end
	end

	def validate(%{"type" => "Undo"} = object, meta) do
	with {:ok, object} <-
	object
	\|> UndoValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Delete"} = object, meta) do
	with cng <- DeleteValidator.cast_and_validate(object),
	do_not_federate <- DeleteValidator.do_not_federate?(cng),
	{:ok, object} <- Ecto.Changeset.apply_action(cng, :insert) do
	object = stringify_keys(object)
	meta = Keyword.put(meta, :do_not_federate, do_not_federate)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Like"} = object, meta) do
	with {:ok, object} <-
	object
	\|> LikeValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "ChatMessage"} = object, meta) do
	with {:ok, object} <-
	object
	\|> ChatMessageValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Question"} = object, meta) do
	with {:ok, object} <-
	object
	\|> QuestionValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	+ def validate(%{"type" => "Answer"} = object, meta) do
	+ with {:ok, object} <-
	+ object
	+ \|> AnswerValidator.cast_and_validate()
	+ \|> Ecto.Changeset.apply_action(:insert) do
	+ object = stringify_keys(object)
	+ {:ok, object, meta}
	+ end
	+ end
	+
	def validate(%{"type" => "EmojiReact"} = object, meta) do
	with {:ok, object} <-
	object
	\|> EmojiReactValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(
	%{"type" => "Create", "object" => %{"type" => "ChatMessage"} = object} = create_activity,
	meta
	) do
	with {:ok, object_data} <- cast_and_apply(object),
	meta = Keyword.put(meta, :object_data, object_data \|> stringify_keys),
	{:ok, create_activity} <-
	create_activity
	\|> CreateChatMessageValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(
	- %{"type" => "Create", "object" => %{"type" => "Question"} = object} = create_activity,
	+ %{"type" => "Create", "object" => %{"type" => objtype} = object} = create_activity,
	meta
	- ) do
	+ )
	+ when objtype in ["Question", "Answer"] do
	with {:ok, object_data} <- cast_and_apply(object),
	meta = Keyword.put(meta, :object_data, object_data \|> stringify_keys),
	{:ok, create_activity} <-
	create_activity
	\|> CreateQuestionValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(%{"type" => "Announce"} = object, meta) do
	with {:ok, object} <-
	object
	\|> AnnounceValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def cast_and_apply(%{"type" => "ChatMessage"} = object) do
	ChatMessageValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Question"} = object) do
	QuestionValidator.cast_and_apply(object)
	end

	+ def cast_and_apply(%{"type" => "Answer"} = object) do
	+ QuestionValidator.cast_and_apply(object)
	+ end
	+
	def cast_and_apply(o), do: {:error, {:validator_not_set, o}}

	# is_struct/1 isn't present in Elixir 1.8.x
	def stringify_keys(%{__struct__: _} = object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) when is_map(object) do
	object
	\|> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
	end

	def stringify_keys(object) when is_list(object) do
	object
	\|> Enum.map(&stringify_keys/1)
	end

	def stringify_keys(object), do: object

	def fetch_actor(object) do
	with {:ok, actor} <- ObjectValidators.ObjectID.cast(object["actor"]) do
	User.get_or_fetch_by_ap_id(actor)
	end
	end

	def fetch_actor_and_object(object) do
	fetch_actor(object)
	Object.normalize(object["object"], true)
	:ok
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/answer_validator.ex b/lib/pleroma/web/activity_pub/object_validators/answer_validator.ex
	new file mode 100644
	index 000000000..0b51eccfa
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/answer_validator.ex
	@@ -0,0 +1,58 @@
	+# 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.AnswerValidator do
	+ use Ecto.Schema
	+
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	+
	+ import Ecto.Changeset
	+
	+ @primary_key false
	+ @derive Jason.Encoder
	+
	+ # Extends from NoteValidator
	+ embedded_schema do
	+ field(:id, Types.ObjectID, primary_key: true)
	+ field(:to, {:array, :string}, default: [])
	+ field(:cc, {:array, :string}, default: [])
	+ field(:bto, {:array, :string}, default: [])
	+ field(:bcc, {:array, :string}, default: [])
	+ field(:type, :string)
	+ field(:name, :string)
	+ field(:inReplyTo, :string)
	+ field(:attributedTo, Types.ObjectID)
	+ 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 changeset(struct, data) do
	+ struct
	+ \|> cast(data, __schema__(:fields))
	+ end
	+
	+ def validate_data(data_cng) do
	+ data_cng
	+ \|> validate_inclusion(:type, ["Answer"])
	+ \|> validate_required([:id, :inReplyTo, :name])
	+ \|> CommonValidations.validate_any_presence([:cc, :to])
	+ \|> CommonValidations.validate_actor_presence()
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index da5dc23bc..9900602e4 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1135 +1,1136 @@
	# 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.FollowingRelationship
	alias Pleroma.Maps
	alias Pleroma.Notification
	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
	Map.put(object, "actor", Containment.get_actor(%{"actor" => 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.error("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}
	\|> Maps.put_if_present("mediaType", media_type)
	\|> Maps.put_if_present("type", Map.get(url \|\| %{}, "type"))

	%{"url" => [attachment_url]}
	\|> Maps.put_if_present("mediaType", media_type)
	\|> Maps.put_if_present("type", data["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" => object_type, "url" => url} = object)
	when object_type in ["Video", "Audio"] and 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, ["audio/", "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

	defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
	with true <- id =~ "follows",
	%User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
	%Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
	{:ok, activity}
	else
	_ -> {:error, nil}
	end
	end

	defp mastodon_follow_hack(_, _), do: {:error, nil}

	defp get_follow_activity(follow_object, followed) do
	with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
	{_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
	{:ok, activity}
	else
	# Can't find the activity. This might a Mastodon 2.3 "Accept"
	{:activity, nil} ->
	mastodon_follow_hack(follow_object, followed)

	_ ->
	{:error, nil}
	end
	end

	# 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

	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 ["Article", "Event", "Note", "Video", "Page", "Answer", "Audio"] do
	+ when objtype in ["Article", "Event", "Note", "Video", "Page", "Audio"] 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),
	data <- Map.put(data, "actor", actor) \|> fix_addressing() do
	object = fix_object(object, options)

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

	with {:ok, created_activity} <- ActivityPub.create(params) 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

	def handle_incoming(
	%{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
	User.update_follower_count(followed)
	User.update_following_count(follower)

	Notification.update_notification_type(followed, follow_activity)

	ActivityPub.accept(%{
	to: follow_activity.data["to"],
	type: "Accept",
	actor: followed,
	object: follow_activity.data["id"],
	local: false,
	activity_id: id
	})
	else
	_e ->
	:error
	end
	end

	def handle_incoming(
	%{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
	{:ok, activity} <-
	ActivityPub.reject(%{
	to: follow_activity.data["to"],
	type: "Reject",
	actor: followed,
	object: follow_activity.data["id"],
	local: false,
	activity_id: id
	}) do
	{:ok, activity}
	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" => "Question"} = object} = data,
	+ %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
	_options
	- ) do
	+ )
	+ when objtype in ["Question", "Answer"] do
	data =
	data
	\|> Map.put("object", fix_object(object))
	\|> fix_addressing()

	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	{:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	def handle_incoming(
	%{"type" => "Create", "object" => %{"type" => "ChatMessage"}} = data,
	_options
	) 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} 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

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 3:02 AM (17 h, 46 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802298
Default Alt Text: (86 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions