No OneTemporary
Actions

Authored By

Unknown

Size

98 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/builder.ex b/lib/pleroma/web/activity_pub/builder.ex
	index 97ceaf08e..71ccbdef5 100644
	--- a/lib/pleroma/web/activity_pub/builder.ex
	+++ b/lib/pleroma/web/activity_pub/builder.ex
	@@ -1,353 +1,400 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Builder do
	@moduledoc """
	This module builds the objects. Meant to be used for creating local objects.

	This module encodes our addressing policies and general shape of our objects.
	"""

	alias Pleroma.Emoji
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI.ActivityDraft
	alias Pleroma.Web.Endpoint

	require Pleroma.Constants

	def accept_or_reject(actor, activity, type) do
	data = %{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => type,
	"object" => activity.data["id"],
	"to" => [activity.actor]
	}

	{:ok, data, []}
	end

	@spec reject(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def reject(actor, rejected_activity) do
	accept_or_reject(actor, rejected_activity, "Reject")
	end

	@spec accept(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def accept(actor, accepted_activity) do
	accept_or_reject(actor, accepted_activity, "Accept")
	end

	@spec follow(User.t(), User.t()) :: {:ok, map(), keyword()}
	def follow(follower, followed) do
	data = %{
	"id" => Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"to" => [followed.ap_id]
	}

	{:ok, data, []}
	end

	+ defp unicode_emoji_react(_object, data, emoji) do
	+ data
	+ \|> Map.put("content", emoji)
	+ \|> Map.put("type", "EmojiReact")
	+ end
	+
	+ defp add_emoji_content(data, emoji, url) do
	+ data
	+ \|> Map.put("content", Emoji.maybe_quote(emoji))
	+ \|> Map.put("type", "EmojiReact")
	+ \|> Map.put("tag", [
	+ %{}
	+ \|> Map.put("id", url)
	+ \|> Map.put("type", "Emoji")
	+ \|> Map.put("name", Emoji.maybe_quote(emoji))
	+ \|> Map.put(
	+ "icon",
	+ %{}
	+ \|> Map.put("type", "Image")
	+ \|> Map.put("url", url)
	+ )
	+ ])
	+ end
	+
	+ defp remote_custom_emoji_react(
	+ %{data: %{"reactions" => existing_reactions}} = object,
	+ data,
	+ emoji
	+ ) do
	+ [emoji_code, instance] = String.split(Emoji.stripped_name(emoji), "@")
	+
	+ matching_reaction =
	+ Enum.find(
	+ existing_reactions,
	+ fn [name, _, url] ->
	+ url = URI.parse(url)
	+ url.host == instance && name == emoji_code
	+ end
	+ )
	+
	+ if matching_reaction do
	+ [name, _, url] = matching_reaction
	+ add_emoji_content(data, name, url)
	+ else
	+ {:error, "Could not react"}
	+ end
	+ end
	+
	+ defp remote_custom_emoji_react(_object, data, emoji) do
	+ {:error, "Could not react"}
	+ end
	+
	+ defp local_custom_emoji_react(data, emoji) do
	+ with %{} = emojo <- Emoji.get(emoji) do
	+ path = emojo \|> Map.get(:file)
	+ url = "#{Endpoint.url()}#{path}"
	+ add_emoji_content(data, emojo.code, url)
	+ else
	+ _ -> {:error, "Emoji does not exist"}
	+ end
	+ end
	+
	+ defp custom_emoji_react(object, data, emoji) do
	+ if String.contains?(emoji, "@") do
	+ remote_custom_emoji_react(object, data, emoji)
	+ else
	+ local_custom_emoji_react(data, emoji)
	+ end
	+ end
	+
	@spec emoji_react(User.t(), Object.t(), String.t()) :: {:ok, map(), keyword()}
	def emoji_react(actor, object, emoji) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	if Emoji.is_unicode_emoji?(emoji) do
	- data
	- \|> Map.put("content", emoji)
	- \|> Map.put("type", "EmojiReact")
	+ unicode_emoji_react(object, data, emoji)
	else
	- with %{} = emojo <- Emoji.get(emoji) do
	- path = emojo \|> Map.get(:file)
	- url = "#{Endpoint.url()}#{path}"
	-
	- data
	- \|> Map.put("content", emoji)
	- \|> Map.put("type", "EmojiReact")
	- \|> Map.put("tag", [
	- %{}
	- \|> Map.put("id", url)
	- \|> Map.put("type", "Emoji")
	- \|> Map.put("name", emojo.code)
	- \|> Map.put(
	- "icon",
	- %{}
	- \|> Map.put("type", "Image")
	- \|> Map.put("url", url)
	- )
	- ])
	- else
	- _ -> {:error, "Emoji does not exist"}
	- end
	+ custom_emoji_react(object, data, emoji)
	end

	{:ok, data, meta}
	end
	end

	@spec undo(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def undo(actor, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => "Undo",
	"object" => object.data["id"],
	"to" => object.data["to"] \|\| [],
	"cc" => object.data["cc"] \|\| []
	}, []}
	end

	@spec delete(User.t(), String.t()) :: {:ok, map(), keyword()}
	def delete(actor, object_id) do
	object = Object.normalize(object_id, fetch: false)

	user = !object && User.get_cached_by_ap_id(object_id)

	to =
	case {object, user} do
	{%Object{}, _} ->
	# We are deleting an object, address everyone who was originally mentioned
	(object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	{_, %User{follower_address: follower_address}} ->
	# We are deleting a user, address the followers of that user
	[follower_address]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object_id,
	"to" => to,
	"type" => "Delete"
	}, []}
	end

	def create(actor, object, recipients) do
	context =
	if is_map(object) do
	object["context"]
	else
	nil
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"to" => recipients,
	"object" => object,
	"type" => "Create",
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}
	\|> Pleroma.Maps.put_if_present("context", context), []}
	end

	@spec note(ActivityDraft.t()) :: {:ok, map(), keyword()}
	def note(%ActivityDraft{} = draft) do
	data =
	%{
	"type" => "Note",
	"to" => draft.to,
	"cc" => draft.cc,
	"content" => draft.content_html,
	"summary" => draft.summary,
	"sensitive" => draft.sensitive,
	"context" => draft.context,
	"attachment" => draft.attachments,
	"actor" => draft.user.ap_id,
	"tag" => Keyword.values(draft.tags) \|> Enum.uniq()
	}
	\|> add_in_reply_to(draft.in_reply_to)
	\|> add_quote(draft.quote)
	\|> Map.merge(draft.extra)

	{:ok, data, []}
	end

	defp add_in_reply_to(object, nil), do: object

	defp add_in_reply_to(object, in_reply_to) do
	with %Object{} = in_reply_to_object <- Object.normalize(in_reply_to, fetch: false) do
	Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
	else
	_ -> object
	end
	end

	defp add_quote(object, nil), do: object

	defp add_quote(object, quote) do
	with %Object{} = quote_object <- Object.normalize(quote, fetch: false) do
	Map.put(object, "quoteUri", quote_object.data["id"])
	else
	_ -> object
	end
	end

	def answer(user, object, name) do
	{:ok,
	%{
	"type" => "Answer",
	"actor" => user.ap_id,
	"attributedTo" => user.ap_id,
	"cc" => [object.data["actor"]],
	"to" => [],
	"name" => name,
	"inReplyTo" => object.data["id"],
	"context" => object.data["context"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"id" => Utils.generate_object_id()
	}, []}
	end

	@spec tombstone(String.t(), String.t()) :: {:ok, map(), keyword()}
	def tombstone(actor, id) do
	{:ok,
	%{
	"id" => id,
	"actor" => actor,
	"type" => "Tombstone"
	}, []}
	end

	@spec like(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def like(actor, object) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	data
	\|> Map.put("type", "Like")

	{:ok, data, meta}
	end
	end

	# Retricted to user updates for now, always public
	@spec update(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def update(actor, object) do
	to = [Pleroma.Constants.as_public(), actor.follower_address]

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Update",
	"actor" => actor.ap_id,
	"object" => object,
	"to" => to
	}, []}
	end

	@spec block(User.t(), User.t()) :: {:ok, map(), keyword()}
	def block(blocker, blocked) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Block",
	"actor" => blocker.ap_id,
	"object" => blocked.ap_id,
	"to" => [blocked.ap_id]
	}, []}
	end

	@spec announce(User.t(), Object.t(), keyword()) :: {:ok, map(), keyword()}
	def announce(actor, object, options \\ []) do
	public? = Keyword.get(options, :public, false)

	to =
	cond do
	actor.ap_id == Relay.ap_id() ->
	[actor.follower_address]

	public? and Visibility.is_local_public?(object) ->
	[actor.follower_address, object.data["actor"], Utils.as_local_public()]

	public? ->
	[actor.follower_address, object.data["actor"], Pleroma.Constants.as_public()]

	true ->
	[actor.follower_address, object.data["actor"]]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"context" => object.data["context"],
	"type" => "Announce",
	"published" => Utils.make_date()
	}, []}
	end

	@spec object_action(User.t(), Object.t()) :: {:ok, map(), keyword()}
	defp object_action(actor, object) do
	object_actor = User.get_cached_by_ap_id(object.data["actor"])

	# Address the actor of the object, and our actor's follower collection if the post is public.
	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	# CC everyone who's been addressed in the object, except ourself and the object actor's
	# follower collection
	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}, []}
	end

	@spec pin(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def pin(%User{} = user, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"target" => pinned_url(user.nickname),
	"object" => object.data["id"],
	"actor" => user.ap_id,
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}, []}
	end

	@spec unpin(User.t(), Object.t()) :: {:ok, map, keyword()}
	def unpin(%User{} = user, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"target" => pinned_url(user.nickname),
	"object" => object.data["id"],
	"actor" => user.ap_id,
	"type" => "Remove",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}, []}
	end

	defp pinned_url(nickname) when is_binary(nickname) do
	Pleroma.Web.Router.Helpers.activity_pub_url(Pleroma.Web.Endpoint, :pinned, nickname)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex b/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	index 306a57a93..6109a0355 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	@@ -1,138 +1,138 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Emoji
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false
	- @emoji_regex ~r/:[A-Za-z0-9_-]+:/
	+ @emoji_regex ~r/:[A-Za-z0-9_-]+(@.+)?:/

	embedded_schema do
	quote do
	unquote do
	import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	message_fields()
	activity_fields()
	tag_fields()
	end
	end

	field(:context, :string)
	field(:content, :string)
	end

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

	def cast_data(data) do
	data =
	data
	\|> fix()

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

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields) -- [:tag])
	\|> cast_embed(:tag)
	end

	defp fix(data) do
	data =
	data
	\|> fix_emoji_qualification()
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_activity_addressing()

	data =
	if Map.has_key?(data, "tag") do
	data
	else
	Map.put(data, "tag", [])
	end

	case Object.normalize(data["object"]) do
	%Object{} = object ->
	data
	\|> CommonFixes.fix_activity_context(object)
	\|> CommonFixes.fix_object_action_recipients(object)

	_ ->
	data
	end
	end

	defp matches_shortcode?(nil), do: false
	defp matches_shortcode?(s), do: Regex.match?(@emoji_regex, s)

	defp fix_emoji_qualification(%{"content" => emoji} = data) do
	new_emoji = Pleroma.Emoji.fully_qualify_emoji(emoji)

	cond do
	Pleroma.Emoji.is_unicode_emoji?(emoji) ->
	data

	Pleroma.Emoji.is_unicode_emoji?(new_emoji) ->
	data \|> Map.put("content", new_emoji)

	true ->
	data
	end
	end

	defp fix_emoji_qualification(data), do: data

	defp validate_emoji(cng) do
	content = get_field(cng, :content)

	if Emoji.is_unicode_emoji?(content) \|\| matches_shortcode?(content) do
	cng
	else
	cng
	\|> add_error(:content, "is not a valid emoji")
	end
	end

	defp maybe_validate_tag_presence(cng) do
	content = get_field(cng, :content)

	if Emoji.is_unicode_emoji?(content) do
	cng
	else
	tag = get_field(cng, :tag)
	emoji_name = Emoji.stripped_name(content)

	case tag do
	[%{name: ^emoji_name, type: "Emoji", icon: %{url: _}}] ->
	cng

	_ ->
	cng
	\|> add_error(:tag, "does not contain an Emoji tag")
	end
	end
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["EmojiReact"])
	\|> validate_required([:id, :type, :object, :actor, :context, :to, :cc, :content])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_emoji()
	\|> maybe_validate_tag_presence()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index b920e8c1d..008aec475 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,882 +1,894 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Ecto.Changeset
	alias Ecto.UUID
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@supported_object_types [
	"Article",
	"Note",
	"Event",
	"Video",
	"Page",
	"Question",
	"Answer",
	"Audio"
	]
	@strip_status_report_states ~w(closed resolved)
	@supported_report_states ~w(open closed resolved)
	@valid_visibilities ~w(public unlisted private direct)

	def as_local_public, do: Endpoint.url() <> "/#Public"

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

	def normalize_params(params) do
	Map.put(params, "actor", get_ap_id(params["actor"]))
	end

	@spec determine_explicit_mentions(map()) :: [any]
	def determine_explicit_mentions(%{"tag" => tag}) when is_list(tag) do
	Enum.flat_map(tag, fn
	%{"type" => "Mention", "href" => href} -> [href]
	_ -> []
	end)
	end

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

	def determine_explicit_mentions(_), do: []

	@spec label_in_collection?(any(), any()) :: boolean()
	defp label_in_collection?(ap_id, coll) when is_binary(coll), do: ap_id == coll
	defp label_in_collection?(ap_id, coll) when is_list(coll), do: ap_id in coll
	defp label_in_collection?(_, _), do: false

	@spec label_in_message?(String.t(), map()) :: boolean()
	def label_in_message?(label, params),
	do:
	[params["to"], params["cc"], params["bto"], params["bcc"]]
	\|> Enum.any?(&label_in_collection?(label, &1))

	@spec unaddressed_message?(map()) :: boolean()
	def unaddressed_message?(params),
	do:
	[params["to"], params["cc"], params["bto"], params["bcc"]]
	\|> Enum.all?(&is_nil(&1))

	@spec recipient_in_message(User.t(), User.t(), map()) :: boolean()
	def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params),
	do:
	label_in_message?(ap_id, params) \|\| unaddressed_message?(params) \|\|
	User.following?(recipient, actor)

	defp extract_list(target) when is_binary(target), do: [target]
	defp extract_list(lst) when is_list(lst), do: lst
	defp extract_list(_), do: []

	def maybe_splice_recipient(ap_id, params) do
	need_splice? =
	!label_in_collection?(ap_id, params["to"]) &&
	!label_in_collection?(ap_id, params["cc"])

	if need_splice? do
	cc = [ap_id \| extract_list(params["cc"])]

	params
	\|> Map.put("cc", cc)
	\|> Maps.safe_put_in(["object", "cc"], cc)
	else
	params
	end
	end

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"#{Endpoint.url()}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	]
	}
	end

	def make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601()
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Helpers.o_status_url(Endpoint, :object, UUID.generate())
	end

	def generate_id(type) do
	"#{Endpoint.url()}/#{type}/#{UUID.generate()}"
	end

	def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
	fake_create_activity = %{
	"to" => object["to"],
	"cc" => object["cc"],
	"type" => "Create",
	"object" => object
	}

	get_notified_from_object(fake_create_activity)
	end

	def get_notified_from_object(object) do
	Notification.get_notified_from_activity(%Activity{data: object}, false)
	end

	def maybe_create_context(context), do: context \|\| generate_id("contexts")

	@doc """
	Enqueues an activity for federation if it's local
	"""
	@spec maybe_federate(any()) :: :ok
	def maybe_federate(%Activity{local: true, data: %{"type" => type}} = activity) do
	outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])

	with true <- Config.get!([:instance, :federating]),
	true <- type != "Block" \|\| outgoing_blocks,
	false <- Visibility.is_local_public?(activity) do
	Pleroma.Web.Federator.publish(activity)
	end

	:ok
	end

	def maybe_federate(_), do: :ok

	@doc """
	Adds an id and a published data if they aren't there,
	also adds it to an included object
	"""
	@spec lazy_put_activity_defaults(map(), boolean) :: map()
	def lazy_put_activity_defaults(map, fake? \\ false)

	def lazy_put_activity_defaults(map, true) do
	map
	\|> Map.put_new("id", "pleroma:fakeid")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", "pleroma:fakecontext")
	\|> lazy_put_object_defaults(true)
	end

	def lazy_put_activity_defaults(map, _fake?) do
	context = maybe_create_context(map["context"])

	map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", context)
	\|> lazy_put_object_defaults(false)
	end

	# Adds an id and published date if they aren't there.
	#
	@spec lazy_put_object_defaults(map(), boolean()) :: map()
	defp lazy_put_object_defaults(%{"object" => map} = activity, true)
	when is_map(map) do
	object =
	map
	\|> Map.put_new("id", "pleroma:fake_object_id")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("fake", true)

	%{activity \| "object" => object}
	end

	defp lazy_put_object_defaults(%{"object" => map} = activity, _)
	when is_map(map) do
	object =
	map
	\|> Map.put_new_lazy("id", &generate_object_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])

	%{activity \| "object" => object}
	end

	defp lazy_put_object_defaults(activity, _), do: activity

	@doc """
	Inserts a full object if it is contained in an activity.
	"""
	def insert_full_object(%{"object" => %{"type" => type} = object_data} = map)
	when type in @supported_object_types do
	with {:ok, object} <- Object.create(object_data) do
	map = Map.put(map, "object", object.data["id"])

	{:ok, map, object}
	end
	end

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

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	@spec get_existing_like(String.t(), map()) :: Activity.t() \| nil
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_object_id(id)
	\|> Activity.Queries.by_type("Like")
	\|> limit(1)
	\|> Repo.one()
	end

	@doc """
	Returns like activities targeting an object
	"""
	def get_object_likes(%{data: %{"id" => id}}) do
	id
	\|> Activity.Queries.by_object_id()
	\|> Activity.Queries.by_type("Like")
	\|> Repo.all()
	end

	@spec make_like_data(User.t(), map(), String.t()) :: map()
	def make_like_data(
	%User{ap_id: ap_id} = actor,
	%{data: %{"actor" => object_actor_id, "id" => id}} = object,
	activity_id
	) do
	object_actor = User.get_cached_by_ap_id(object_actor_id)

	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	%{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_emoji_reaction_data(user, object, emoji, activity_id) do
	make_like_data(user, object, activity_id)
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", emoji)
	end

	@spec update_element_in_object(String.t(), list(any), Object.t(), integer() \| nil) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def update_element_in_object(property, element, object, count \\ nil) do
	length =
	count \|\|
	length(element)

	data =
	Map.merge(
	object.data,
	%{"#{property}_count" => length, "#{property}s" => element}
	)

	object
	\|> Changeset.change(data: data)
	\|> Object.update_and_set_cache()
	end

	@spec add_emoji_reaction_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}

	def add_emoji_reaction_to_object(
	%Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
	object
	) do
	reactions = get_cached_emoji_reactions(object)
	- emoji = stripped_emoji_name(emoji)
	+ emoji = Pleroma.Emoji.stripped_name(emoji)
	url = emoji_url(emoji, activity)

	new_reactions =
	case Enum.find_index(reactions, fn [candidate, _, candidate_url] ->
	if is_nil(candidate_url) do
	emoji == candidate
	else
	url == candidate_url
	end
	end) do
	nil ->
	reactions ++ [[emoji, [actor], url]]

	index ->
	List.update_at(
	reactions,
	index,
	fn [emoji, users, url] -> [emoji, Enum.uniq([actor \| users]), url] end
	)
	end

	count = emoji_count(new_reactions)

	update_element_in_object("reaction", new_reactions, object, count)
	end

	- defp stripped_emoji_name(name) do
	- name
	- \|> String.replace_leading(":", "")
	- \|> String.replace_trailing(":", "")
	- end
	-
	defp emoji_url(
	name,
	%Activity{
	data: %{
	"tag" => [
	%{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}
	]
	}
	}
	),
	do: url

	defp emoji_url(_, _), do: nil

	def emoji_count(reactions_list) do
	Enum.reduce(reactions_list, 0, fn [_, users, _], acc -> acc + length(users) end)
	end

	def remove_emoji_reaction_from_object(
	%Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
	object
	) do
	- emoji = stripped_emoji_name(emoji)
	+ emoji = Pleroma.Emoji.stripped_name(emoji)
	reactions = get_cached_emoji_reactions(object)
	url = emoji_url(emoji, activity)

	new_reactions =
	case Enum.find_index(reactions, fn [candidate, _, candidate_url] ->
	if is_nil(candidate_url) do
	emoji == candidate
	else
	url == candidate_url
	end
	end) do
	nil ->
	reactions

	index ->
	List.update_at(
	reactions,
	index,
	fn [emoji, users, url] -> [emoji, List.delete(users, actor), url] end
	)
	\|> Enum.reject(fn [_, users, _] -> Enum.empty?(users) end)
	end

	count = emoji_count(new_reactions)
	update_element_in_object("reaction", new_reactions, object, count)
	end

	def get_cached_emoji_reactions(object) do
	if is_list(object.data["reactions"]) do
	object.data["reactions"]
	else
	[]
	end
	end

	@spec add_like_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	[actor \| fetch_likes(object)]
	\|> Enum.uniq()
	\|> update_likes_in_object(object)
	end

	@spec remove_like_from_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	object
	\|> fetch_likes()
	\|> List.delete(actor)
	\|> update_likes_in_object(object)
	end

	defp update_likes_in_object(likes, object) do
	update_element_in_object("like", likes, object)
	end

	defp fetch_likes(object) do
	if is_list(object.data["likes"]) do
	object.data["likes"]
	else
	[]
	end
	end

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	@spec update_follow_state_for_all(Activity.t(), String.t()) :: {:ok, Activity \| nil}
	def update_follow_state_for_all(
	%Activity{data: %{"actor" => actor, "object" => object}} = activity,
	state
	) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> Activity.Queries.by_actor(actor)
	\|> Activity.Queries.by_object_id(object)
	\|> where(fragment("data->>'state' = 'pending'") or fragment("data->>'state' = 'accept'"))
	\|> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
	\|> Repo.update_all([])

	activity = Activity.get_by_id(activity.id)

	{:ok, activity}
	end

	@doc """
	Makes a follow activity data for the given follower and followed
	"""
	def make_follow_data(
	%User{ap_id: follower_id},
	%User{ap_id: followed_id} = _followed,
	activity_id
	) do
	%{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"cc" => [Pleroma.Constants.as_public()],
	"object" => followed_id,
	"state" => "pending"
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^follower_id)
	# this is to use the index
	\|> Activity.Queries.by_object_id(followed_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def fetch_latest_undo(%User{ap_id: ap_id}) do
	"Undo"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^ap_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def get_latest_reaction(internal_activity_id, %{ap_id: ap_id}, emoji) do
	%{data: %{"object" => object_ap_id}} = Activity.get_by_id(internal_activity_id)
	-
	emoji = Pleroma.Emoji.maybe_quote(emoji)

	"EmojiReact"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^ap_id)
	- \|> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
	+ \|> custom_emoji_discriminator(emoji)
	\|> Activity.Queries.by_object_id(object_ap_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	+ defp custom_emoji_discriminator(query, emoji) do
	+ if String.contains?(emoji, "@") do
	+ stripped = Pleroma.Emoji.stripped_name(emoji)
	+ [name, domain] = String.split(stripped, "@")
	+ domain_pattern = "%" <> domain <> "%"
	+ emoji_pattern = Pleroma.Emoji.maybe_quote(name)
	+
	+ query
	+ \|> where([activity], fragment("?->>'content' = ?
	+ AND EXISTS (
	+ SELECT FROM jsonb_array_elements(?->'tag') elem
	+ WHERE elem->>'id' ILIKE ?
	+ )", activity.data, ^emoji_pattern, activity.data, ^domain_pattern))
	+ else
	+ query
	+ \|> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
	+ end
	+ end
	+
	#### Announce-related helpers

	@doc """
	Returns an existing announce activity if the notice has already been announced
	"""
	@spec get_existing_announce(String.t(), map()) :: Activity.t() \| nil
	def get_existing_announce(actor, %{data: %{"id" => ap_id}}) do
	"Announce"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^actor)
	# this is to use the index
	\|> Activity.Queries.by_object_id(ap_id)
	\|> Repo.one()
	end

	@doc """
	Make announce activity data for the given actor and object
	"""
	# for relayed messages, we only want to send to subscribers
	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	false
	) do
	%{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address],
	"cc" => [],
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	true
	) do
	%{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_undo_data(
	%User{ap_id: actor, follower_address: follower_address},
	%Activity{
	data: %{"id" => undone_activity_id, "context" => context},
	actor: undone_activity_actor
	},
	activity_id \\ nil
	) do
	%{
	"type" => "Undo",
	"actor" => actor,
	"object" => undone_activity_id,
	"to" => [follower_address, undone_activity_actor],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => context
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	@spec add_announce_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def add_announce_to_object(
	%Activity{data: %{"actor" => actor}},
	object
	) do
	unless actor \|> User.get_cached_by_ap_id() \|> User.invisible?() do
	announcements = take_announcements(object)

	with announcements <- Enum.uniq([actor \| announcements]) do
	update_element_in_object("announcement", announcements, object)
	end
	else
	{:ok, object}
	end
	end

	def add_announce_to_object(_, object), do: {:ok, object}

	@spec remove_announce_from_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	with announcements <- List.delete(take_announcements(object), actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	defp take_announcements(%{data: %{"announcements" => announcements}} = _)
	when is_list(announcements),
	do: announcements

	defp take_announcements(_), do: []

	#### Unfollow-related helpers

	def make_unfollow_data(follower, followed, follow_activity, activity_id) do
	%{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	"object" => follow_activity.data
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	#### Block-related helpers
	@spec fetch_latest_block(User.t(), User.t()) :: Activity.t() \| nil
	def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	"Block"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^blocker_id)
	# this is to use the index
	\|> Activity.Queries.by_object_id(blocked_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def make_block_data(blocker, blocked, activity_id) do
	%{
	"type" => "Block",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => blocked.ap_id
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	#### Create-related helpers

	def make_create_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	#### Flag-related helpers
	@spec make_flag_data(map(), map()) :: map()
	def make_flag_data(%{actor: actor, context: context, content: content} = params, additional) do
	%{
	"type" => "Flag",
	"actor" => actor.ap_id,
	"content" => content,
	"object" => build_flag_object(params),
	"context" => context,
	"state" => "open"
	}
	\|> Map.merge(additional)
	end

	def make_flag_data(_, _), do: %{}

	defp build_flag_object(%{account: account, statuses: statuses}) do
	[account.ap_id \| build_flag_object(%{statuses: statuses})]
	end

	defp build_flag_object(%{statuses: statuses}) do
	Enum.map(statuses \|\| [], &build_flag_object/1)
	end

	defp build_flag_object(%Activity{data: %{"id" => id}, object: %{data: data}}) do
	activity_actor = User.get_by_ap_id(data["actor"])

	%{
	"type" => "Note",
	"id" => id,
	"content" => data["content"],
	"published" => data["published"],
	"actor" =>
	AccountView.render(
	"show.json",
	%{user: activity_actor, skip_visibility_check: true}
	)
	}
	end

	defp build_flag_object(act) when is_map(act) or is_binary(act) do
	id =
	case act do
	%Activity{} = act -> act.data["id"]
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end

	case Activity.get_by_ap_id_with_object(id) do
	%Activity{} = activity ->
	build_flag_object(activity)

	nil ->
	if activity = Activity.get_by_object_ap_id_with_object(id) do
	build_flag_object(activity)
	else
	%{"id" => id, "deleted" => true}
	end
	end
	end

	defp build_flag_object(_), do: []

	#### Report-related helpers
	def get_reports(params, page, page_size) do
	params =
	params
	\|> Map.put(:type, "Flag")
	\|> Map.put(:skip_preload, true)
	\|> Map.put(:preload_report_notes, true)
	\|> Map.put(:total, true)
	\|> Map.put(:limit, page_size)
	\|> Map.put(:offset, (page - 1) * page_size)

	ActivityPub.fetch_activities([], params, :offset)
	end

	def update_report_state(%Activity{} = activity, state)
	when state in @strip_status_report_states do
	{:ok, stripped_activity} = strip_report_status_data(activity)

	new_data =
	activity.data
	\|> Map.put("state", state)
	\|> Map.put("object", stripped_activity.data["object"])

	activity
	\|> Changeset.change(data: new_data)
	\|> Repo.update()
	end

	def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
	new_data = Map.put(activity.data, "state", state)

	activity
	\|> Changeset.change(data: new_data)
	\|> Repo.update()
	end

	def update_report_state(activity_ids, state) when state in @supported_report_states do
	activities_num = length(activity_ids)

	from(a in Activity, where: a.id in ^activity_ids)
	\|> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
	\|> Repo.update_all([])
	\|> case do
	{^activities_num, _} -> :ok
	_ -> {:error, activity_ids}
	end
	end

	def update_report_state(_, _), do: {:error, "Unsupported state"}

	def strip_report_status_data(activity) do
	[actor \| reported_activities] = activity.data["object"]

	stripped_activities =
	Enum.map(reported_activities, fn
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end)

	new_data = put_in(activity.data, ["object"], [actor \| stripped_activities])

	{:ok, %{activity \| data: new_data}}
	end

	def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
	[to, cc, recipients] =
	activity
	\|> get_updated_targets(visibility)
	\|> Enum.map(&Enum.uniq/1)

	object_data =
	activity.object.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	{:ok, object} =
	activity.object
	\|> Object.change(%{data: object_data})
	\|> Object.update_and_set_cache()

	activity_data =
	activity.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	activity
	\|> Map.put(:object, object)
	\|> Activity.change(%{data: activity_data, recipients: recipients})
	\|> Repo.update()
	end

	def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}

	defp get_updated_targets(
	%Activity{data: %{"to" => to} = data, recipients: recipients},
	visibility
	) do
	cc = Map.get(data, "cc", [])
	follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
	public = Pleroma.Constants.as_public()

	case visibility do
	"public" ->
	to = [public \| List.delete(to, follower_address)]
	cc = [follower_address \| List.delete(cc, public)]
	recipients = [public \| recipients]
	[to, cc, recipients]

	"private" ->
	to = [follower_address \| List.delete(to, public)]
	cc = List.delete(cc, public)
	recipients = List.delete(recipients, public)
	[to, cc, recipients]

	"unlisted" ->
	to = [follower_address \| List.delete(to, public)]
	cc = [public \| List.delete(cc, follower_address)]
	recipients = recipients ++ [follower_address, public]
	[to, cc, recipients]

	_ ->
	[to, cc, recipients]
	end
	end

	def get_existing_votes(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Create")
	\|> Activity.with_preloaded_object()
	\|> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
	\|> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
	\|> Repo.all()
	end
	end
	diff --git a/lib/pleroma/web/common_api.ex b/lib/pleroma/web/common_api.ex
	index bc5e26cf7..23d353dc2 100644
	--- a/lib/pleroma/web/common_api.ex
	+++ b/lib/pleroma/web/common_api.ex
	@@ -1,545 +1,546 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI do
	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Object
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI.ActivityDraft

	import Pleroma.Web.Gettext
	import Pleroma.Web.CommonAPI.Utils

	require Pleroma.Constants
	require Logger

	def block(blocker, blocked) do
	with {:ok, block_data, _} <- Builder.block(blocker, blocked),
	{:ok, block, _} <- Pipeline.common_pipeline(block_data, local: true) do
	{:ok, block}
	end
	end

	def unblock(blocker, blocked) do
	with {_, %Activity{} = block} <- {:fetch_block, Utils.fetch_latest_block(blocker, blocked)},
	{:ok, unblock_data, _} <- Builder.undo(blocker, block),
	{:ok, unblock, _} <- Pipeline.common_pipeline(unblock_data, local: true) do
	{:ok, unblock}
	else
	{:fetch_block, nil} ->
	if User.blocks?(blocker, blocked) do
	User.unblock(blocker, blocked)
	{:ok, :no_activity}
	else
	{:error, :not_blocking}
	end

	e ->
	e
	end
	end

	def follow(follower, followed) do
	timeout = Pleroma.Config.get([:activitypub, :follow_handshake_timeout])

	with {:ok, follow_data, _} <- Builder.follow(follower, followed),
	{:ok, activity, _} <- Pipeline.common_pipeline(follow_data, local: true),
	{:ok, follower, followed} <- User.wait_and_refresh(timeout, follower, followed) do
	if activity.data["state"] == "reject" do
	{:error, :rejected}
	else
	{:ok, follower, followed, activity}
	end
	end
	end

	def unfollow(follower, unfollowed) do
	with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
	{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed),
	{:ok, _subscription} <- User.unsubscribe(follower, unfollowed) do
	{:ok, follower}
	end
	end

	def accept_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, accept_data, _} <- Builder.accept(followed, follow_activity),
	{:ok, _activity, _} <- Pipeline.common_pipeline(accept_data, local: true) do
	{:ok, follower}
	end
	end

	def reject_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, reject_data, _} <- Builder.reject(followed, follow_activity),
	{:ok, _activity, _} <- Pipeline.common_pipeline(reject_data, local: true) do
	{:ok, follower}
	end
	end

	def delete(activity_id, user) do
	with {_, %Activity{data: %{"object" => _, "type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(activity_id)},
	{_, %Object{} = object, _} <-
	{:find_object, Object.normalize(activity, fetch: false), activity},
	true <- User.superuser?(user) \|\| user.ap_id == object.data["actor"],
	{:ok, delete_data, _} <- Builder.delete(user, object.data["id"]),
	{:ok, delete, _} <- Pipeline.common_pipeline(delete_data, local: true) do
	{:ok, delete}
	else
	{:find_activity, _} ->
	{:error, :not_found}

	{:find_object, nil, %Activity{data: %{"actor" => actor, "object" => object}}} ->
	# We have the create activity, but not the object, it was probably pruned.
	# Insert a tombstone and try again
	with {:ok, tombstone_data, _} <- Builder.tombstone(actor, object),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	delete(activity_id, user)
	else
	_ ->
	Logger.error(
	"Could not insert tombstone for missing object on deletion. Object is #{object}."
	)

	{:error, dgettext("errors", "Could not delete")}
	end

	_ ->
	{:error, dgettext("errors", "Could not delete")}
	end
	end

	def repeat(id, user, params \\ %{}) do
	with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id(id),
	object = %Object{} <- Object.normalize(activity, fetch: false),
	{_, nil} <- {:existing_announce, Utils.get_existing_announce(user.ap_id, object)},
	public = public_announce?(object, params),
	{:ok, announce, _} <- Builder.announce(user, object, public: public),
	{:ok, activity, _} <- Pipeline.common_pipeline(announce, local: true) do
	{:ok, activity}
	else
	{:existing_announce, %Activity{} = announce} ->
	{:ok, announce}

	_ ->
	{:error, :not_found}
	end
	end

	def unrepeat(id, user) do
	with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(id)},
	%Object{} = note <- Object.normalize(activity, fetch: false),
	%Activity{} = announce <- Utils.get_existing_announce(user.ap_id, note),
	{:ok, undo, _} <- Builder.undo(user, announce),
	{:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
	{:ok, activity}
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unrepeat")}
	end
	end

	@spec favorite(User.t(), binary()) :: {:ok, Activity.t() \| :already_liked} \| {:error, any()}
	def favorite(%User{} = user, id) do
	case favorite_helper(user, id) do
	{:ok, _} = res ->
	res

	{:error, :not_found} = res ->
	res

	{:error, e} ->
	Logger.error("Could not favorite #{id}. Error: #{inspect(e, pretty: true)}")
	{:error, dgettext("errors", "Could not favorite")}
	end
	end

	def favorite_helper(user, id) do
	with {_, %Activity{object: object}} <- {:find_object, Activity.get_by_id_with_object(id)},
	{_, {:ok, like_object, meta}} <- {:build_object, Builder.like(user, object)},
	{_, {:ok, %Activity{} = activity, _meta}} <-
	{:common_pipeline,
	Pipeline.common_pipeline(like_object, Keyword.put(meta, :local, true))} do
	{:ok, activity}
	else
	{:find_object, _} ->
	{:error, :not_found}

	{:common_pipeline, {:error, {:validate, {:error, changeset}}}} = e ->
	if {:object, {"already liked by this actor", []}} in changeset.errors do
	{:ok, :already_liked}
	else
	{:error, e}
	end

	e ->
	{:error, e}
	end
	end

	def unfavorite(id, user) do
	with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(id)},
	%Object{} = note <- Object.normalize(activity, fetch: false),
	%Activity{} = like <- Utils.get_existing_like(user.ap_id, note),
	{:ok, undo, _} <- Builder.undo(user, like),
	{:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
	{:ok, activity}
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unfavorite")}
	end
	end

	def react_with_emoji(id, user, emoji) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	object <- Object.normalize(activity, fetch: false),
	{:ok, emoji_react, _} <- Builder.emoji_react(user, object, emoji),
	{:ok, activity, _} <- Pipeline.common_pipeline(emoji_react, local: true) do
	{:ok, activity}
	else
	- _ -> {:error, dgettext("errors", "Could not add reaction emoji")}
	+ _ ->
	+ {:error, dgettext("errors", "Could not add reaction emoji")}
	end
	end

	def unreact_with_emoji(id, user, emoji) do
	with %Activity{} = reaction_activity <- Utils.get_latest_reaction(id, user, emoji),
	{:ok, undo, _} <- Builder.undo(user, reaction_activity),
	{:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
	{:ok, activity}
	else
	_ ->
	{:error, dgettext("errors", "Could not remove reaction emoji")}
	end
	end

	def vote(user, %{data: %{"type" => "Question"}} = object, choices) do
	with :ok <- validate_not_author(object, user),
	:ok <- validate_existing_votes(user, object),
	{:ok, options, choices} <- normalize_and_validate_choices(choices, object) do
	answer_activities =
	Enum.map(choices, fn index ->
	{:ok, answer_object, _meta} =
	Builder.answer(user, object, Enum.at(options, index)["name"])

	{:ok, activity_data, _meta} = Builder.create(user, answer_object, [])

	{:ok, activity, _meta} =
	activity_data
	\|> Map.put("cc", answer_object["cc"])
	\|> Map.put("context", answer_object["context"])
	\|> Pipeline.common_pipeline(local: true)

	# TODO: Do preload of Pleroma.Object in Pipeline
	Activity.normalize(activity.data)
	end)

	object = Object.get_cached_by_ap_id(object.data["id"])
	{:ok, answer_activities, object}
	end
	end

	defp validate_not_author(%{data: %{"actor" => ap_id}}, %{ap_id: ap_id}),
	do: {:error, dgettext("errors", "Poll's author can't vote")}

	defp validate_not_author(_, _), do: :ok

	defp validate_existing_votes(%{ap_id: ap_id}, object) do
	if Utils.get_existing_votes(ap_id, object) == [] do
	:ok
	else
	{:error, dgettext("errors", "Already voted")}
	end
	end

	defp get_options_and_max_count(%{data: %{"anyOf" => any_of}})
	when is_list(any_of) and any_of != [],
	do: {any_of, Enum.count(any_of)}

	defp get_options_and_max_count(%{data: %{"oneOf" => one_of}})
	when is_list(one_of) and one_of != [],
	do: {one_of, 1}

	defp normalize_and_validate_choices(choices, object) do
	choices = Enum.map(choices, fn i -> if is_binary(i), do: String.to_integer(i), else: i end)
	{options, max_count} = get_options_and_max_count(object)
	count = Enum.count(options)

	with {_, true} <- {:valid_choice, Enum.all?(choices, &(&1 < count))},
	{_, true} <- {:count_check, Enum.count(choices) <= max_count} do
	{:ok, options, choices}
	else
	{:valid_choice, _} -> {:error, dgettext("errors", "Invalid indices")}
	{:count_check, _} -> {:error, dgettext("errors", "Too many choices")}
	end
	end

	def public_announce?(_, %{visibility: visibility})
	when visibility in ~w{public unlisted private direct},
	do: visibility in ~w(public unlisted)

	def public_announce?(object, _) do
	Visibility.is_public?(object)
	end

	def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}

	def get_visibility(%{visibility: visibility}, in_reply_to, _)
	when visibility in ~w{public local unlisted private direct},
	do: {visibility, get_replied_to_visibility(in_reply_to)}

	def get_visibility(%{visibility: "list:" <> list_id}, in_reply_to, _) do
	visibility = {:list, String.to_integer(list_id)}
	{visibility, get_replied_to_visibility(in_reply_to)}
	end

	def get_visibility(_, in_reply_to, _) when not is_nil(in_reply_to) do
	visibility = get_replied_to_visibility(in_reply_to)
	{visibility, visibility}
	end

	def get_visibility(_, in_reply_to, _), do: {"public", get_replied_to_visibility(in_reply_to)}

	def get_replied_to_visibility(nil), do: nil

	def get_replied_to_visibility(activity) do
	with %Object{} = object <- Object.normalize(activity, fetch: false) do
	Visibility.get_visibility(object)
	end
	end

	def get_quoted_visibility(nil), do: nil

	def get_quoted_visibility(activity), do: get_replied_to_visibility(activity)

	def check_expiry_date({:ok, nil} = res), do: res

	def check_expiry_date({:ok, in_seconds}) do
	expiry = DateTime.add(DateTime.utc_now(), in_seconds)

	if Pleroma.Workers.PurgeExpiredActivity.expires_late_enough?(expiry) do
	{:ok, expiry}
	else
	{:error, "Expiry date is too soon"}
	end
	end

	def check_expiry_date(expiry_str) do
	Ecto.Type.cast(:integer, expiry_str)
	\|> check_expiry_date()
	end

	def post(user, %{status: _} = data) do
	with {:ok, draft} <- ActivityDraft.create(user, data) do
	ActivityPub.create(draft.changes, draft.preview?)
	end
	end

	@spec pin(String.t(), User.t()) :: {:ok, Activity.t()} \| {:error, term()}
	def pin(id, %User{} = user) do
	with %Activity{} = activity <- create_activity_by_id(id),
	true <- activity_belongs_to_actor(activity, user.ap_id),
	true <- object_type_is_allowed_for_pin(activity.object),
	true <- activity_is_public(activity),
	{:ok, pin_data, _} <- Builder.pin(user, activity.object),
	{:ok, _pin, _} <-
	Pipeline.common_pipeline(pin_data,
	local: true,
	activity_id: id
	) do
	{:ok, activity}
	else
	{:error, {:side_effects, error}} -> error
	error -> error
	end
	end

	defp create_activity_by_id(id) do
	with nil <- Activity.create_by_id_with_object(id) do
	{:error, :not_found}
	end
	end

	defp activity_belongs_to_actor(%{actor: actor}, actor), do: true
	defp activity_belongs_to_actor(_, _), do: {:error, :ownership_error}

	defp object_type_is_allowed_for_pin(%{data: %{"type" => type}}) do
	with false <- type in ["Note", "Article", "Question"] do
	{:error, :not_allowed}
	end
	end

	defp activity_is_public(activity) do
	with false <- Visibility.is_public?(activity) do
	{:error, :visibility_error}
	end
	end

	@spec unpin(String.t(), User.t()) :: {:ok, User.t()} \| {:error, term()}
	def unpin(id, user) do
	with %Activity{} = activity <- create_activity_by_id(id),
	{:ok, unpin_data, _} <- Builder.unpin(user, activity.object),
	{:ok, _unpin, _} <-
	Pipeline.common_pipeline(unpin_data,
	local: true,
	activity_id: activity.id,
	expires_at: activity.data["expires_at"],
	featured_address: user.featured_address
	) do
	{:ok, activity}
	end
	end

	def add_mute(user, activity, params \\ %{}) do
	expires_in = Map.get(params, :expires_in, 0)

	with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]),
	_ <- Pleroma.Notification.mark_context_as_read(user, activity.data["context"]) do
	if expires_in > 0 do
	Pleroma.Workers.MuteExpireWorker.enqueue(
	"unmute_conversation",
	%{"user_id" => user.id, "activity_id" => activity.id},
	schedule_in: expires_in
	)
	end

	{:ok, activity}
	else
	{:error, _} -> {:error, dgettext("errors", "conversation is already muted")}
	end
	end

	def remove_mute(%User{} = user, %Activity{} = activity) do
	ThreadMute.remove_mute(user.id, activity.data["context"])
	{:ok, activity}
	end

	def remove_mute(user_id, activity_id) do
	with {:user, %User{} = user} <- {:user, User.get_by_id(user_id)},
	{:activity, %Activity{} = activity} <- {:activity, Activity.get_by_id(activity_id)} do
	remove_mute(user, activity)
	else
	{what, result} = error ->
	Logger.warn(
	"CommonAPI.remove_mute/2 failed. #{what}: #{result}, user_id: #{user_id}, activity_id: #{activity_id}"
	)

	{:error, error}
	end
	end

	def thread_muted?(%User{id: user_id}, %{data: %{"context" => context}})
	when is_binary(context) do
	ThreadMute.exists?(user_id, context)
	end

	def thread_muted?(_, _), do: false

	def report(user, data) do
	with {:ok, account} <- get_reported_account(data.account_id),
	{:ok, {content_html, _, _}} <- make_report_content_html(data[:comment]),
	{:ok, statuses} <- get_report_statuses(account, data) do
	ActivityPub.flag(%{
	context: Utils.generate_context_id(),
	actor: user,
	account: account,
	statuses: statuses,
	content: content_html,
	forward: Map.get(data, :forward, false)
	})
	end
	end

	defp get_reported_account(account_id) do
	case User.get_cached_by_id(account_id) do
	%User{} = account -> {:ok, account}
	_ -> {:error, dgettext("errors", "Account not found")}
	end
	end

	def update_report_state(activity_ids, state) when is_list(activity_ids) do
	case Utils.update_report_state(activity_ids, state) do
	:ok -> {:ok, activity_ids}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_report_state(activity_id, state) do
	with %Activity{} = activity <- Activity.get_by_id(activity_id) do
	Utils.update_report_state(activity, state)
	else
	nil -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_activity_scope(activity_id, opts \\ %{}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
	{:ok, activity} <- toggle_sensitive(activity, opts) do
	set_visibility(activity, opts)
	else
	nil -> {:error, :not_found}
	{:error, reason} -> {:error, reason}
	end
	end

	defp toggle_sensitive(activity, %{sensitive: sensitive}) when sensitive in ~w(true false) do
	toggle_sensitive(activity, %{sensitive: String.to_existing_atom(sensitive)})
	end

	defp toggle_sensitive(%Activity{object: object} = activity, %{sensitive: sensitive})
	when is_boolean(sensitive) do
	new_data = Map.put(object.data, "sensitive", sensitive)

	{:ok, object} =
	object
	\|> Object.change(%{data: new_data})
	\|> Object.update_and_set_cache()

	{:ok, Map.put(activity, :object, object)}
	end

	defp toggle_sensitive(activity, _), do: {:ok, activity}

	defp set_visibility(activity, %{visibility: visibility}) do
	Utils.update_activity_visibility(activity, visibility)
	end

	defp set_visibility(activity, _), do: {:ok, activity}

	def hide_reblogs(%User{} = user, %User{} = target) do
	UserRelationship.create_reblog_mute(user, target)
	end

	def show_reblogs(%User{} = user, %User{} = target) do
	UserRelationship.delete_reblog_mute(user, target)
	end

	def get_user(ap_id, fake_record_fallback \\ true) do
	cond do
	user = User.get_cached_by_ap_id(ap_id) ->
	user

	user = User.get_by_guessed_nickname(ap_id) ->
	user

	fake_record_fallback ->
	# TODO: refactor (fake records is never a good idea)
	User.error_user(ap_id)

	true ->
	nil
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index d838c4673..0d2571ab8 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,641 +1,641 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusView do
	use Pleroma.Web, :view

	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.PollView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.PleromaAPI.EmojiReactionController

	import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1, visible_for_user?: 2]

	# This is a naive way to do this, just spawning a process per activity
	# to fetch the preview. However it should be fine considering
	# pagination is restricted to 40 activities at a time
	defp fetch_rich_media_for_activities(activities) do
	Enum.each(activities, fn activity ->
	spawn(fn ->
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end)
	end)
	end

	# TODO: Add cached version.
	defp get_replied_to_activities([]), do: %{}

	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	# DEPRECATED This field seems to be a left-over from the StatusNet era.
	# If your application uses `pleroma.conversation_id`: this field is deprecated.
	# It is currently stubbed instead by doing a CRC32 of the context, and
	# clearing the MSB to avoid overflow exceptions with signed integers on the
	# different clients using this field (Java/Kotlin code, mostly; see Husky.)
	# This should be removed in a future version of Pleroma. Pleroma-FE currently
	# depends on this field, as well.
	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context) do
	use Bitwise

	:erlang.crc32(context)
	\|> band(bnot(0x8000_0000))
	end

	defp get_context_id(_), do: nil

	# Check if the user reblogged this status
	defp reblogged?(activity, %User{ap_id: ap_id}) do
	with %Object{data: %{"announcements" => announcements}} when is_list(announcements) <-
	Object.normalize(activity, fetch: false) do
	ap_id in announcements
	else
	_ -> false
	end
	end

	# False if the user is logged out
	defp reblogged?(_activity, _user), do: false

	def render("index.json", opts) do
	reading_user = opts[:for]
	# To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
	activities = Enum.filter(opts.activities, & &1)

	# Start fetching rich media before doing anything else, so that later calls to get the cards
	# only block for timeout in the worst case, as opposed to
	# length(activities_with_links) * timeout
	fetch_rich_media_for_activities(activities)
	replied_to_activities = get_replied_to_activities(activities)

	parent_activities =
	activities
	\|> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
	\|> Enum.map(&Object.normalize(&1, fetch: false).data["id"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Activity.with_preloaded_bookmark(reading_user)
	\|> Activity.with_set_thread_muted_field(reading_user)
	\|> Repo.all()

	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	# Note: unresolved users are filtered out
	actors =
	(activities ++ parent_activities)
	\|> Enum.map(&CommonAPI.get_user(&1.data["actor"], false))
	\|> Enum.filter(& &1)

	UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
	end

	opts =
	opts
	\|> Map.put(:replied_to_activities, replied_to_activities)
	\|> Map.put(:parent_activities, parent_activities)
	\|> Map.put(:relationships, relationships_opt)

	safe_render_many(activities, StatusView, "show.json", opts)
	end

	def render(
	"show.json",
	%{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
	) do
	user = CommonAPI.get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])
	object = Object.normalize(activity, fetch: false)

	reblogged_parent_activity =
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(
	opts[:parent_activities],
	object.data["id"]
	)
	else
	Activity.create_by_object_ap_id(object.data["id"])
	\|> Activity.with_preloaded_bookmark(opts[:for])
	\|> Activity.with_set_thread_muted_field(opts[:for])
	\|> Repo.one()
	end

	reblog_rendering_opts = Map.put(opts, :activity, reblogged_parent_activity)
	reblogged = render("show.json", reblog_rendering_opts)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmarked = Activity.get_bookmark(reblogged_parent_activity, opts[:for]) != nil

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: object.data["id"],
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: reblogged?(reblogged_parent_activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmarked),
	muted: false,
	pinned: pinned?,
	sensitive: false,
	spoiler_text: "",
	visibility: get_visibility(activity),
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: build_application(object.data["generator"]),
	language: nil,
	emojis: [],
	pleroma: %{
	local: activity.local,
	pinned_at: pinned_at
	}
	}
	end

	def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	user = CommonAPI.get_user(activity.data["actor"])
	user_follower_address = user.follower_address

	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0

	hashtags = Object.hashtags(object)
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	tags = Object.tags(object)

	tag_mentions =
	tags
	\|> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
	\|> Enum.map(fn tag -> tag["href"] end)

	mentions =
	(object.data["to"] ++ tag_mentions)
	\|> Enum.uniq()
	\|> Enum.map(fn
	Pleroma.Constants.as_public() -> nil
	^user_follower_address -> nil
	ap_id -> User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmarked = Activity.get_bookmark(activity, opts[:for]) != nil

	client_posted_this_activity = opts[:for] && user.id == opts[:for].id

	expires_at =
	with true <- client_posted_this_activity,
	%Oban.Job{scheduled_at: scheduled_at} <-
	Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
	scheduled_at
	else
	_ -> nil
	end

	thread_muted? =
	cond do
	is_nil(opts[:for]) -> false
	is_boolean(activity.thread_muted?) -> activity.thread_muted?
	true -> CommonAPI.thread_muted?(opts[:for], activity)
	end

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["published"])

	reply_to = get_reply_to(activity, opts)

	reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content"
	)

	content_plaintext =
	content
	\|> Activity.HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content"
	)

	summary = object.data["summary"] \|\| ""

	card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	object.data["url"] \|\| object.data["external_url"] \|\| object.data["id"]
	end

	direct_conversation_id =
	with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
	{_, true} <- {:include_id, opts[:with_direct_conversation_id]},
	{_, %User{} = for_user} <- {:for_user, opts[:for]} do
	Activity.direct_conversation_id(activity, for_user)
	else
	{:direct_conversation_id, participation_id} when is_integer(participation_id) ->
	participation_id

	_e ->
	nil
	end

	emoji_reactions =
	object.data
	\|> Map.get("reactions", [])
	\|> EmojiReactionController.filter_allowed_users(
	opts[:for],
	Map.get(opts, :with_muted, false)
	)
	\|> Stream.map(fn {emoji, users, url} ->
	build_emoji_map(emoji, users, url, opts[:for])
	end)
	\|> Enum.to_list()

	# Status muted state (would do 1 request per status unless user mutes are preloaded)
	muted =
	thread_muted? \|\|
	UserRelationship.exists?(
	get_in(opts, [:relationships, :user_relationships]),
	:mute,
	opts[:for],
	user,
	fn for_user, user -> User.mutes?(for_user, user) end
	)

	{pinned?, pinned_at} = pin_data(object, user)

	quote = Activity.get_quoted_activity_from_object(object)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	content: content_html,
	text: opts[:with_source] && object.data["source"],
	created_at: created_at,
	reblogs_count: announcement_count,
	replies_count: object.data["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: reblogged?(activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmarked),
	muted: muted,
	pinned: pinned?,
	sensitive: sensitive,
	spoiler_text: summary,
	visibility: get_visibility(object),
	media_attachments: attachments,
	poll: render(PollView, "show.json", object: object, for: opts[:for]),
	mentions: mentions,
	tags: build_tags(tags),
	application: build_application(object.data["generator"]),
	language: nil,
	emojis: build_emojis(object.data["emoji"]),
	quote_id: if(quote, do: quote.id, else: nil),
	quote: maybe_render_quote(quote, opts),
	emoji_reactions: emoji_reactions,
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	context: object.data["context"],
	in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
	content: %{"text/plain" => content_plaintext},
	spoiler_text: %{"text/plain" => summary},
	expires_at: expires_at,
	direct_conversation_id: direct_conversation_id,
	thread_muted: thread_muted?,
	emoji_reactions: emoji_reactions,
	parent_visible: visible_for_user?(reply_to, opts[:for]),
	pinned_at: pinned_at
	},
	akkoma: %{
	source: object.data["source"]
	}
	}
	end

	def render("show.json", _) do
	nil
	end

	def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
	page_url_data = URI.parse(page_url)

	page_url_data =
	if is_binary(rich_media["url"]) do
	URI.merge(page_url_data, URI.parse(rich_media["url"]))
	else
	page_url_data
	end

	page_url = page_url_data \|> to_string

	image_url_data =
	if is_binary(rich_media["image"]) do
	URI.parse(rich_media["image"])
	else
	nil
	end

	image_url = build_image_url(image_url_data, page_url_data)

	%{
	type: "link",
	provider_name: page_url_data.host,
	provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url \|> MediaProxy.url(),
	title: rich_media["title"] \|\| "",
	description: rich_media["description"] \|\| "",
	pleroma: %{
	opengraph: rich_media
	}
	}
	end

	def render("card.json", _), do: nil

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href = attachment_url["href"] \|> MediaProxy.url()
	href_preview = attachment_url["href"] \|> MediaProxy.preview_url()
	meta = render("attachment_meta.json", %{attachment: attachment})

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)

	%{
	id: to_string(attachment["id"] \|\| hash_id),
	url: href,
	remote_url: href,
	preview_url: href_preview,
	text_url: href,
	type: type,
	description: attachment["name"],
	pleroma: %{mime_type: media_type},
	blurhash: attachment["blurhash"]
	}
	\|> Maps.put_if_present(:meta, meta)
	end

	def render("attachment_meta.json", %{
	attachment: %{"url" => [%{"width" => width, "height" => height} \| _]}
	})
	when is_integer(width) and is_integer(height) do
	%{
	original: %{
	width: width,
	height: height,
	aspect: width / height
	}
	}
	end

	def render("attachment_meta.json", _), do: nil

	def render("context.json", %{activity: activity, activities: activities, user: user}) do
	%{ancestors: ancestors, descendants: descendants} =
	activities
	\|> Enum.reverse()
	\|> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
	\|> Map.put_new(:ancestors, [])
	\|> Map.put_new(:descendants, [])

	%{
	ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
	descendants: render("index.json", for: user, activities: descendants, as: :activity)
	}
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- replied_to_activities[object.data["inReplyTo"]] do
	# If user didn't participate in the thread
	Activity.get_in_reply_to_activity(activity)
	end
	end

	def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
	Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
	else
	nil
	end
	end

	def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
	url = object.data["url"] \|\| object.data["id"]

	"<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
	end

	def render_content(object), do: object.data["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags
	\|> Enum.filter(&is_binary/1)
	\|> Enum.map(&%{name: &1, url: "#{Pleroma.Web.Endpoint.url()}/tag/#{URI.encode(&1)}"})
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

	%{shortcode: name, url: url, static_url: url, visible_in_picker: false}
	end)
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pin_data(%Object{data: %{"id" => object_id}}, %User{pinned_objects: pinned_objects}) do
	if pinned_at = pinned_objects[object_id] do
	{true, Utils.to_masto_date(pinned_at)}
	else
	{false, nil}
	end
	end

	defp build_emoji_map(emoji, users, url, current_user) do
	%{
	- name: emoji,
	+ name: Pleroma.Web.PleromaAPI.EmojiReactionView.emoji_name(emoji, url),
	count: length(users),
	url: MediaProxy.url(url),
	me: !!(current_user && current_user.ap_id in users),
	account_ids: Enum.map(users, fn user -> User.get_cached_by_ap_id(user).id end)
	}
	end

	@spec build_application(map() \| nil) :: map() \| nil
	defp build_application(%{"type" => _type, "name" => name, "url" => url}),
	do: %{name: name, website: url}

	defp build_application(_), do: nil

	# Workaround for Elixir issue #10771
	# Avoid applying URI.merge unless necessary
	# TODO: revert to always attempting URI.merge(image_url_data, page_url_data)
	# when Elixir 1.12 is the minimum supported version
	@spec build_image_url(struct() \| nil, struct()) :: String.t() \| nil
	defp build_image_url(
	%URI{scheme: image_scheme, host: image_host} = image_url_data,
	%URI{} = _page_url_data
	)
	when not is_nil(image_scheme) and not is_nil(image_host) do
	image_url_data \|> to_string
	end

	defp build_image_url(%URI{} = image_url_data, %URI{} = page_url_data) do
	URI.merge(page_url_data, image_url_data) \|> to_string
	end

	defp build_image_url(_, _), do: nil

	defp maybe_render_quote(nil, _), do: nil

	defp maybe_render_quote(quote, opts) do
	with %User{} = quoted_user <- User.get_cached_by_ap_id(quote.actor),
	false <- Map.get(opts, :do_not_recurse, false),
	true <- visible_for_user?(quote, opts[:for]),
	false <- User.blocks?(opts[:for], quoted_user),
	false <- User.mutes?(opts[:for], quoted_user) do
	opts =
	opts
	\|> Map.put(:activity, quote)
	\|> Map.put(:do_not_recurse, true)

	render("show.json", opts)
	else
	_ -> nil
	end
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/emoji_reaction_controller.ex b/lib/pleroma/web/pleroma_api/controllers/emoji_reaction_controller.ex
	index 91658587a..0933363a6 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/emoji_reaction_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/emoji_reaction_controller.ex
	@@ -1,97 +1,105 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.EmojiReactionController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(OAuthScopesPlug, %{scopes: ["write:statuses"]} when action in [:create, :delete])

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:statuses"], fallback: :proceed_unauthenticated}
	when action == :index
	)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.EmojiReactionOperation

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	def index(%{assigns: %{user: user}} = conn, %{id: activity_id} = params) do
	with true <- Pleroma.Config.get([:instance, :show_reactions]),
	%Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
	%Object{data: %{"reactions" => reactions}} when is_list(reactions) <-
	Object.normalize(activity, fetch: false) do
	reactions =
	reactions
	\|> filter(params)
	\|> filter_allowed_users(user, Map.get(params, :with_muted, false))

	render(conn, "index.json", emoji_reactions: reactions, user: user)
	else
	_e -> json(conn, [])
	end
	end

	def filter_allowed_users(reactions, user, with_muted) do
	exclude_ap_ids =
	if is_nil(user) do
	[]
	else
	User.cached_blocked_users_ap_ids(user) ++
	if not with_muted, do: User.cached_muted_users_ap_ids(user), else: []
	end

	filter_emoji = fn emoji, users, url ->
	case Enum.reject(users, &(&1 in exclude_ap_ids)) do
	[] -> nil
	users -> {emoji, users, url}
	end
	end

	reactions
	\|> Stream.map(fn
	[emoji, users, url] when is_list(users) -> filter_emoji.(emoji, users, url)
	{emoji, users, url} when is_list(users) -> filter_emoji.(emoji, users, url)
	{emoji, users} when is_list(users) -> filter_emoji.(emoji, users, nil)
	_ -> nil
	end)
	\|> Stream.reject(&is_nil/1)
	end

	defp filter(reactions, %{emoji: emoji}) when is_binary(emoji) do
	Enum.filter(reactions, fn [e, _, _] -> e == emoji end)
	end

	defp filter(reactions, _), do: reactions

	def create(%{assigns: %{user: user}} = conn, %{id: activity_id, emoji: emoji}) do
	- emoji = Pleroma.Emoji.maybe_quote(emoji)
	+ emoji =
	+ emoji
	+ \|> Pleroma.Emoji.fully_qualify_emoji()
	+ \|> Pleroma.Emoji.maybe_quote()

	with {:ok, _activity} <- CommonAPI.react_with_emoji(activity_id, user, emoji) do
	activity = Activity.get_by_id(activity_id)

	conn
	\|> put_view(StatusView)
	\|> render("show.json", activity: activity, for: user, as: :activity)
	end
	end

	def delete(%{assigns: %{user: user}} = conn, %{id: activity_id, emoji: emoji}) do
	+ emoji =
	+ emoji
	+ \|> Pleroma.Emoji.fully_qualify_emoji()
	+ \|> Pleroma.Emoji.maybe_quote()
	+
	with {:ok, _activity} <- CommonAPI.unreact_with_emoji(activity_id, user, emoji) do
	activity = Activity.get_by_id(activity_id)

	conn
	\|> put_view(StatusView)
	\|> render("show.json", activity: activity, for: user, as: :activity)
	end
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/views/emoji_reaction_view.ex b/lib/pleroma/web/pleroma_api/views/emoji_reaction_view.ex
	index 9993480db..4335228b6 100644
	--- a/lib/pleroma/web/pleroma_api/views/emoji_reaction_view.ex
	+++ b/lib/pleroma/web/pleroma_api/views/emoji_reaction_view.ex
	@@ -1,35 +1,47 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.EmojiReactionView do
	use Pleroma.Web, :view

	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MediaProxy

	+ def emoji_name(emoji, nil), do: emoji
	+
	+ def emoji_name(emoji, url) do
	+ url = URI.parse(url)
	+
	+ if url.host == Pleroma.Web.Endpoint.host() do
	+ emoji
	+ else
	+ "#{emoji}@#{url.host}"
	+ end
	+ end
	+
	def render("index.json", %{emoji_reactions: emoji_reactions} = opts) do
	render_many(emoji_reactions, __MODULE__, "show.json", opts)
	end

	def render("show.json", %{emoji_reaction: {emoji, user_ap_ids, url}, user: user}) do
	users = fetch_users(user_ap_ids)

	%{
	- name: emoji,
	+ name: emoji_name(emoji, url),
	count: length(users),
	accounts: render(AccountView, "index.json", users: users, for: user),
	url: MediaProxy.url(url),
	me: !!(user && user.ap_id in user_ap_ids)
	}
	end

	defp fetch_users(user_ap_ids) do
	user_ap_ids
	\|> Enum.map(&Pleroma.User.get_cached_by_ap_id/1)
	\|> Enum.filter(fn
	%{is_active: true} -> true
	_ -> false
	end)
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/emoji_reaction_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/emoji_reaction_controller_test.exs
	index 4898179e6..6864b37cb 100644
	--- a/test/pleroma/web/pleroma_api/controllers/emoji_reaction_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/emoji_reaction_controller_test.exs
	@@ -1,242 +1,326 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.EmojiReactionControllerTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.Web.ConnCase

	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "PUT /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	- {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
	+ note = insert(:note, user: user, data: %{"reactions" => [["👍", [other_user.ap_id], nil]]})
	+ activity = insert(:note_activity, note: note, user: user)

	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	- \|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/☕")
	+ \|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/\u26A0")
	\|> json_response_and_validate_schema(200)

	- # We return the status, but this our implementation detail.
	assert %{"id" => id} = result
	assert to_string(activity.id) == id

	assert result["pleroma"]["emoji_reactions"] == [
	%{
	- "name" => "☕",
	+ "name" => "👍",
	+ "count" => 1,
	+ "me" => true,
	+ "url" => nil,
	+ "account_ids" => [other_user.id]
	+ },
	+ %{
	+ "name" => "\u26A0\uFE0F",
	"count" => 1,
	"me" => true,
	"url" => nil,
	"account_ids" => [other_user.id]
	}
	]

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})

	ObanHelpers.perform_all()
	+
	# Reacting with a custom emoji
	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/:dinosaur:")
	\|> json_response_and_validate_schema(200)

	- # We return the status, but this our implementation detail.
	assert %{"id" => id} = result
	assert to_string(activity.id) == id

	assert result["pleroma"]["emoji_reactions"] == [
	%{
	"name" => "dinosaur",
	"count" => 1,
	"me" => true,
	"url" => "http://localhost:4001/emoji/dino walking.gif",
	"account_ids" => [other_user.id]
	}
	]

	+ # Reacting with a remote emoji
	+ note =
	+ insert(:note,
	+ user: user,
	+ data: %{"reactions" => [["wow", [other_user.ap_id], "https://remote/emoji/wow"]]}
	+ )
	+
	+ activity = insert(:note_activity, note: note, user: user)
	+
	+ result =
	+ conn
	+ \|> assign(:user, user)
	+ \|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:statuses"]))
	+ \|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/:wow@remote:")
	+ \|> json_response(200)
	+
	+ assert result["pleroma"]["emoji_reactions"] == [
	+ %{
	+ "name" => "wow@remote",
	+ "count" => 2,
	+ "me" => true,
	+ "url" => "https://remote/emoji/wow",
	+ "account_ids" => [user.id, other_user.id]
	+ }
	+ ]
	+
	+ # Reacting with a remote custom emoji that hasn't been reacted with yet
	+ note =
	+ insert(:note,
	+ user: user
	+ )
	+
	+ activity = insert(:note_activity, note: note, user: user)
	+
	+ assert conn
	+ \|> assign(:user, user)
	+ \|> assign(:token, insert(:oauth_token, user: user, scopes: ["write:statuses"]))
	+ \|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/:wow@remote:")
	+ \|> json_response(400)
	+
	# Reacting with a non-emoji
	assert conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> put("/api/v1/pleroma/statuses/#{activity.id}/reactions/x")
	\|> json_response_and_validate_schema(400)
	end

	test "DELETE /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	- {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
	+ note =
	+ insert(:note,
	+ user: user,
	+ data: %{"reactions" => [["wow", [user.ap_id], "https://remote/emoji/wow"]]}
	+ )
	+
	+ activity = insert(:note_activity, note: note, user: user)
	+
	+ ObanHelpers.perform_all()
	+
	{:ok, _reaction_activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
	{:ok, _reaction_activity} = CommonAPI.react_with_emoji(activity.id, other_user, ":dinosaur:")

	+ {:ok, _reaction_activity} =
	+ CommonAPI.react_with_emoji(activity.id, other_user, ":wow@remote:")
	+
	ObanHelpers.perform_all()

	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/☕")

	assert %{"id" => id} = json_response_and_validate_schema(result, 200)
	assert to_string(activity.id) == id

	# Remove custom emoji

	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	\|> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/:dinosaur:")

	assert %{"id" => id} = json_response_and_validate_schema(result, 200)
	assert to_string(activity.id) == id

	ObanHelpers.perform_all()

	object = Object.get_by_ap_id(activity.data["object"])

	- assert object.data["reaction_count"] == 0
	+ assert object.data["reaction_count"] == 2
	+
	+ # Remove custom remote emoji
	+ result =
	+ conn
	+ \|> assign(:user, other_user)
	+ \|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	+ \|> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/:wow@remote:")
	+ \|> json_response(200)
	+
	+ assert result["pleroma"]["emoji_reactions"] == [
	+ %{
	+ "name" => "wow@remote",
	+ "count" => 1,
	+ "me" => false,
	+ "url" => "https://remote/emoji/wow",
	+ "account_ids" => [user.id]
	+ }
	+ ]
	+
	+ # Remove custom remote emoji that hasn't been reacted with yet
	+ assert conn
	+ \|> assign(:user, other_user)
	+ \|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["write:statuses"]))
	+ \|> delete("/api/v1/pleroma/statuses/#{activity.id}/reactions/:zoop@remote:")
	+ \|> json_response(400)
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	doomed_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert result == []

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, doomed_user, "🎅")

	User.perform(:delete, doomed_user)

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	[%{"name" => "🎅", "count" => 1, "accounts" => [represented_user], "me" => false}] = result

	assert represented_user["id"] == other_user.id

	result =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:statuses"]))
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert [%{"name" => "🎅", "count" => 1, "accounts" => [_represented_user], "me" => true}] =
	result
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions?with_muted=true", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	token = insert(:oauth_token, user: user, scopes: ["read:statuses"])

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user2, "🎅")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user3, "🎅")

	result =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert [%{"name" => "🎅", "count" => 2}] = result

	User.mute(user, user3)

	result =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert [%{"name" => "🎅", "count" => 1}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> assign(:token, token)
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [%{"name" => "🎅", "count" => 2}] = result
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions with :show_reactions disabled", %{conn: conn} do
	clear_config([:instance, :show_reactions], false)

	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert result == []
	end

	test "GET /api/v1/pleroma/statuses/:id/reactions/:emoji", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions/🎅")
	\|> json_response_and_validate_schema(200)

	assert result == []

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	assert [
	%{
	"name" => "🎅",
	"count" => 1,
	"accounts" => [represented_user],
	"me" => false,
	"url" => nil
	}
	] =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/reactions/🎅")
	\|> json_response_and_validate_schema(200)

	assert represented_user["id"] == other_user.id
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 2:04 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799172
Default Alt Text: (98 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions