No OneTemporary
Actions

Size

216 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/emoji-reaction-url-escape.fix b/changelog.d/emoji-reaction-url-escape.fix
	new file mode 100644
	index 000000000..c3a1c8823
	--- /dev/null
	+++ b/changelog.d/emoji-reaction-url-escape.fix
	@@ -0,0 +1 @@
	+Encode custom emoji URLs in EmojiReact activity tags.
	diff --git a/lib/pleroma/emoji.ex b/lib/pleroma/emoji.ex
	index 21bcb0111..2fe425955 100644
	--- a/lib/pleroma/emoji.ex
	+++ b/lib/pleroma/emoji.ex
	@@ -1,209 +1,239 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji do
	@moduledoc """
	This GenServer stores in an ETS table the list of the loaded emojis,
	and also allows to reload the list at runtime.
	"""
	use GenServer

	alias Pleroma.Emoji.Combinations
	alias Pleroma.Emoji.Loader
	+ alias Pleroma.Utils.URIEncoding
	+ alias Pleroma.Web.Endpoint

	require Logger

	@ets __MODULE__.Ets
	@ets_options [
	:ordered_set,
	:protected,
	:named_table,
	{:read_concurrency, true}
	]

	defstruct [:code, :file, :tags, :safe_code, :safe_file]

	@type t :: %__MODULE__{}

	@doc "Build emoji struct"
	def build({code, file, tags}) do
	%__MODULE__{
	code: code,
	file: file,
	tags: tags,
	safe_code: Pleroma.HTML.strip_tags(code),
	safe_file: Pleroma.HTML.strip_tags(file)
	}
	end

	def build({code, file}), do: build({code, file, []})

	@doc false
	def start_link(_) do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	@doc "Reloads the emojis from disk."
	@spec reload() :: :ok
	def reload do
	GenServer.call(__MODULE__, :reload)
	end

	@doc "Returns the path of the emoji `name`."
	@spec get(String.t()) :: Pleroma.Emoji.t() \| nil
	def get(name) do
	name = maybe_strip_name(name)

	case :ets.lookup(@ets, name) do
	[{_, emoji}] -> emoji
	_ -> nil
	end
	end

	@spec exist?(String.t()) :: boolean()
	def exist?(name), do: not is_nil(get(name))

	@doc "Returns all the emojos!!"
	@spec get_all() :: list({String.t(), String.t(), String.t()})
	def get_all do
	:ets.tab2list(@ets)
	end

	@doc "Clear out old emojis"
	def clear_all, do: :ets.delete_all_objects(@ets)

	@doc false
	def init(_) do
	@ets = :ets.new(@ets, @ets_options)
	GenServer.cast(self(), :reload)
	{:ok, nil}
	end

	@doc false
	def handle_cast(:reload, state) do
	update_emojis(Loader.load())
	{:noreply, state}
	end

	@doc false
	def handle_call(:reload, _from, state) do
	update_emojis(Loader.load())
	{:reply, :ok, state}
	end

	@doc false
	def terminate(_, _) do
	:ok
	end

	@doc false
	def code_change(_old_vsn, state, _extra) do
	update_emojis(Loader.load())
	{:ok, state}
	end

	defp update_emojis(emojis) do
	:ets.insert(@ets, emojis)
	end

	@external_resource "lib/pleroma/emoji-test.txt"

	regional_indicators =
	Enum.map(127_462..127_487, fn codepoint ->
	<<codepoint::utf8>>
	end)

	emojis =
	@external_resource
	\|> File.read!()
	\|> String.split("\n")
	\|> Enum.filter(fn line ->
	line != "" and not String.starts_with?(line, "#") and
	String.contains?(line, "fully-qualified")
	end)
	\|> Enum.map(fn line ->
	line
	\|> String.split(";", parts: 2)
	\|> hd()
	\|> String.trim()
	\|> String.split()
	\|> Enum.map(fn codepoint ->
	<<String.to_integer(codepoint, 16)::utf8>>
	end)
	\|> Enum.join()
	end)
	\|> Enum.uniq()

	emojis = emojis ++ regional_indicators

	for emoji <- emojis do
	def unicode?(unquote(emoji)), do: true
	end

	def unicode?(_), do: false

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

	def custom?(s) when is_binary(s), do: Regex.match?(@emoji_regex, s)

	def custom?(_), do: false

	def maybe_strip_name(name) when is_binary(name), do: String.trim(name, ":")

	def maybe_strip_name(name), do: name

	def maybe_quote(name) when is_binary(name) do
	if unicode?(name) do
	name
	else
	if String.starts_with?(name, ":") do
	name
	else
	":#{name}:"
	end
	end
	end

	def maybe_quote(name), do: name

	def emoji_url(%{"type" => "EmojiReact", "content" => _, "tag" => []}), do: nil

	def emoji_url(%{"type" => "EmojiReact", "content" => emoji, "tag" => tags}) do
	emoji = maybe_strip_name(emoji)

	tag =
	tags
	\|> Enum.find(fn tag ->
	tag["type"] == "Emoji" && !is_nil(tag["name"]) && tag["name"] == emoji
	end)

	if is_nil(tag) do
	nil
	else
	tag
	\|> Map.get("icon")
	\|> Map.get("url")
	end
	end

	def emoji_url(_), do: nil

	+ @spec local_url(String.t() \| nil) :: String.t() \| nil
	+ def local_url(nil), do: nil
	+
	+ def local_url("http" <> _ = url) do
	+ URIEncoding.encode_url(url)
	+ end
	+
	+ def local_url("/" <> _ = path) do
	+ path = URIEncoding.encode_url(path, bypass_parse: true, bypass_decode: true)
	+ Endpoint.url() <> path
	+ end
	+
	+ def local_url(path) when is_binary(path) do
	+ local_url("/" <> path)
	+ end
	+
	+ def build_emoji_tag({name, url}) do
	+ url = URIEncoding.encode_url(url)
	+
	+ %{
	+ "icon" => %{"url" => "#{url}", "type" => "Image"},
	+ "name" => ":" <> name <> ":",
	+ "type" => "Emoji",
	+ "updated" => "1970-01-01T00:00:00Z",
	+ "id" => url
	+ }
	+ end
	+
	def emoji_name_with_instance(name, url) do
	url = url \|> URI.parse() \|> Map.get(:host)
	"#{name}@#{url}"
	end

	emoji_qualification_map =
	emojis
	\|> Enum.filter(&String.contains?(&1, "\uFE0F"))
	\|> Combinations.variate_emoji_qualification()

	for {qualified, unqualified_list} <- emoji_qualification_map do
	for unqualified <- unqualified_list do
	def fully_qualify_emoji(unquote(unqualified)), do: unquote(qualified)
	end
	end

	def fully_qualify_emoji(emoji), do: emoji
	end
	diff --git a/lib/pleroma/emoji/formatter.ex b/lib/pleroma/emoji/formatter.ex
	index 87fd35f13..9238bf912 100644
	--- a/lib/pleroma/emoji/formatter.ex
	+++ b/lib/pleroma/emoji/formatter.ex
	@@ -1,52 +1,51 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji.Formatter do
	alias Pleroma.Emoji
	alias Pleroma.HTML
	- alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

	def emojify(text) do
	emojify(text, Emoji.get_all())
	end

	def emojify(text, nil), do: text

	def emojify(text, emoji, strip \\ false) do
	Enum.reduce(emoji, text, fn
	{_, %Emoji{safe_code: emoji, safe_file: file}}, text ->
	String.replace(text, ":#{emoji}:", prepare_emoji_html(emoji, file, strip))

	{unsafe_emoji, unsafe_file}, text ->
	emoji = HTML.strip_tags(unsafe_emoji)
	file = HTML.strip_tags(unsafe_file)
	String.replace(text, ":#{emoji}:", prepare_emoji_html(emoji, file, strip))
	end)
	\|> HTML.filter_tags()
	end

	defp prepare_emoji_html(_emoji, _file, true), do: ""

	defp prepare_emoji_html(emoji, file, _strip) do
	"<img class='emoji' alt='#{emoji}' title='#{emoji}' src='#{MediaProxy.url(file)}' />"
	end

	def demojify(text) do
	emojify(text, Emoji.get_all(), true)
	end

	def demojify(text, nil), do: text

	@doc "Outputs a list of the emoji-Maps in a text"
	def get_emoji_map(text) when is_binary(text) do
	Emoji.get_all()
	\|> Enum.filter(fn {emoji, %Emoji{}} -> String.contains?(text, ":#{emoji}:") end)
	\|> Enum.reduce(%{}, fn {name, %Emoji{file: file}}, acc ->
	- Map.put(acc, name, to_string(URI.merge(Endpoint.url(), file)))
	+ Map.put(acc, name, Emoji.local_url(file))
	end)
	end

	def get_emoji_map(_), do: %{}
	end
	diff --git a/lib/pleroma/web/activity_pub/builder.ex b/lib/pleroma/web/activity_pub/builder.ex
	index 046316024..167c769a9 100644
	--- a/lib/pleroma/web/activity_pub/builder.ex
	+++ b/lib/pleroma/web/activity_pub/builder.ex
	@@ -1,434 +1,425 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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.Activity
	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
	tag = [
	- %{
	- "id" => url,
	- "type" => "Emoji",
	- "name" => Emoji.maybe_quote(emoji),
	- "icon" => %{
	- "type" => "Image",
	- "url" => url
	- }
	- }
	+ Emoji.build_emoji_tag({Emoji.maybe_strip_name(emoji), url})
	]

	data
	\|> Map.put("content", Emoji.maybe_quote(emoji))
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("tag", tag)
	end

	defp remote_custom_emoji_react(
	%{data: %{"reactions" => existing_reactions}},
	data,
	emoji
	) do
	[emoji_code, instance] = String.split(Emoji.maybe_strip_name(emoji), "@")

	matching_reaction =
	Enum.find(
	existing_reactions,
	fn [name, _, url] ->
	if url != nil do
	url = URI.parse(url)
	url.host == instance && name == emoji_code
	end
	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 %{file: path} = emojo <- Emoji.get(emoji) do
	- url = "#{Endpoint.url()}#{path}"
	+ url = Emoji.local_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.unicode?(emoji) do
	unicode_emoji_react(object, data, emoji)
	else
	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_post)
	\|> 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_post) do
	with %Object{} = quote_object <- Object.normalize(quote_post, fetch: false) do
	Map.put(object, "quoteUrl", quote_object.data["id"])
	else
	_ -> object
	end
	end

	def chat_message(actor, recipient, content, opts \\ []) do
	basic = %{
	"id" => Utils.generate_object_id(),
	"actor" => actor.ap_id,
	"type" => "ChatMessage",
	"to" => [recipient],
	"content" => content,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"emoji" => Emoji.Formatter.get_emoji_map(content)
	}

	case opts[:attachment] do
	%Object{data: attachment_data} ->
	{
	:ok,
	Map.put(basic, "attachment", attachment_data),
	[]
	}

	_ ->
	{:ok, basic, []}
	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

	@spec update(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def update(actor, object) do
	{to, cc} =
	if object["type"] in Pleroma.Constants.actor_types() do
	# User updates, always public
	{[Pleroma.Constants.as_public(), actor.follower_address], []}
	else
	# Status updates, follow the recipients in the object
	{object["to"] \|\| [], object["cc"] \|\| []}
	end

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

	@spec block(User.t(), User.t(), map()) :: {:ok, map(), keyword()}
	def block(blocker, blocked, params \\ %{}) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Block",
	"actor" => blocker.ap_id,
	"object" => blocked.ap_id,
	"to" => [blocked.ap_id]
	}, Keyword.new(params)}
	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.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.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/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 6e04d95e6..ba6f4030d 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1092 +1,1081 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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.
	"""
	@behaviour Pleroma.Web.ActivityPub.Transmogrifier.API
	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	+ alias Pleroma.Emoji
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator

	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

	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_history(&fix_object/1)
	end

	defp maybe_fix_object(%{"attributedTo" => _} = object), do: fix_object(object)
	defp maybe_fix_object(object), do: object

	defp fix_history(%{"formerRepresentations" => %{"orderedItems" => list}} = obj, fix_fun)
	when is_list(list) do
	update_in(obj["formerRepresentations"]["orderedItems"], fn h -> Enum.map(h, fix_fun) end)
	end

	defp fix_history(obj, _), do: obj

	defp fix_recursive(obj, fun) do
	# unlike Erlang, Elixir does not support recursive inline functions
	# which would allow us to avoid reconstructing this on every recursion
	rec_fun = fn
	obj when is_map(obj) -> fix_recursive(obj, fun)
	# there may be simple AP IDs in history (or object field)
	obj -> obj
	end

	obj
	\|> fun.()
	\|> fix_history(rec_fun)
	\|> then(fn
	%{"object" => object} = doc when is_map(object) ->
	update_in(doc["object"], rec_fun)

	apdoc ->
	apdoc
	end)
	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

	@doc """
	Bovine compatibility
	https://codeberg.org/bovine/bovine/issues/53
	"""
	def fix_addressing_public(map, field) do
	addrs = Map.get(map, field, []) \|> List.wrap()

	Map.put(
	map,
	field,
	Enum.map(addrs, fn
	"Public" -> Pleroma.Constants.as_public()
	"as:Public" -> Pleroma.Constants.as_public()
	x -> x
	end)
	)
	end

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

	def fix_explicit_addressing(%{"to" => to, "cc" => cc} = object, follower_collection) do
	explicit_mentions =
	Utils.determine_explicit_mentions(object) ++
	[Pleroma.Constants.as_public(), follower_collection]

	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.filter(& &1)
	\|> 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

	# 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_addressing(object) do
	{:ok, %User{follower_address: follower_collection}} =
	object
	\|> Containment.get_actor()
	\|> User.get_or_fetch_by_ap_id()

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

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

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

	def fix_in_reply_to(object, options \\ [])

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
	when not is_nil(in_reply_to) do
	in_reply_to_id = prepare_in_reply_to(in_reply_to)
	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("context", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.drop(["conversation", "inReplyToAtomUri"])
	else
	_ ->
	object
	end
	else
	object
	end
	end

	def fix_in_reply_to(object, _options), do: object

	def fix_quote_url_and_maybe_fetch(object, options \\ []) do
	quote_url =
	case CommonFixes.fix_quote_url(object) do
	%{"quoteUrl" => quote_url} -> quote_url
	_ -> nil
	end

	with {:quoting?, true} <- {:quoting?, not is_nil(quote_url)},
	{:ok, quoted_object} <- get_obj_helper(quote_url, options),
	%Activity{} <- Activity.get_create_by_object_ap_id(quoted_object.data["id"]) do
	Map.put(object, "quoteUrl", quoted_object.data["id"])
	else
	{:quoting?, _} ->
	object

	_ ->
	object
	end
	end

	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) && url =~ Pleroma.Constants.mime_regex() ->
	url["mediaType"]

	is_bitstring(data["mediaType"]) && data["mediaType"] =~ Pleroma.Constants.mime_regex() ->
	data["mediaType"]

	is_bitstring(data["mimeType"]) && data["mimeType"] =~ Pleroma.Constants.mime_regex() ->
	data["mimeType"]

	true ->
	nil
	end

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

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

	%{
	"url" => [attachment_url],
	"type" => data["type"] \|\| "Document"
	}
	\|> Maps.put_if_present("mediaType", media_type)
	\|> Maps.put_if_present("name", data["name"])
	\|> Maps.put_if_present("blurhash", data["blurhash"])
	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(%{"url" => url} = object) when 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 -> is_map(data) and 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)

	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
	%{"name" => "#" <> hashtag} -> String.downcase(hashtag)
	%{"name" => hashtag} -> String.downcase(hashtag)
	end)

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

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

	def fix_tag(object), do: object

	# prefer content over contentMap
	def fix_content_map(%{"content" => content} = object) when not_empty_string(content), 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

	defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
	when is_binary(reply_id) do
	options = Keyword.put(options, :fetch, true)

	with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
	Map.put(object, "type", "Answer")
	else
	_ -> object
	end
	end

	defp fix_type(object, _options), do: object

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

	def handle_incoming(data, options \\ []) do
	data
	\|> fix_recursive(&strip_internal_fields/1)
	\|> handle_incoming_normalized(options)
	end

	# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
	# with nil ID.
	defp handle_incoming_normalized(
	%{"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
	defp handle_incoming_normalized(%{"id" => nil}, _options), do: :error
	defp handle_incoming_normalized(%{"id" => ""}, _options), do: :error
	# length of https:// = 8, should validate better, but good enough for now.
	defp handle_incoming_normalized(%{"id" => id}, _options)
	when is_binary(id) and byte_size(id) < 8,
	do: :error

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

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

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

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

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

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

	# Rewrite misskey likes into EmojiReacts
	defp handle_incoming_normalized(
	%{
	"type" => "Like",
	"content" => content
	} = data,
	options
	)
	when is_binary(content) do
	data
	\|> Map.put("type", "EmojiReact")
	\|> handle_incoming_normalized(options)
	end

	defp handle_incoming_normalized(
	%{
	"type" => "Like",
	"_misskey_reaction" => reaction
	} = data,
	options
	) do
	data
	\|> Map.put("content", @misskey_reactions[reaction] \|\| reaction)
	\|> handle_incoming_normalized(options)
	end

	defp handle_incoming_normalized(
	%{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
	options
	)
	when objtype in ~w{Question Answer ChatMessage Audio Video Event Article Note Page Image} do
	fetch_options = Keyword.put(options, :depth, (options[:depth] \|\| 0) + 1)

	object =
	data["object"]
	\|> strip_internal_fields()
	\|> fix_type(fetch_options)
	\|> fix_in_reply_to(fetch_options)
	\|> fix_quote_url_and_maybe_fetch(fetch_options)

	data = Map.put(data, "object", object)
	options = Keyword.put(options, :local, false)

	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	nil <- Activity.get_create_by_object_ap_id(obj_id),
	{:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
	{:ok, activity}
	else
	%Activity{} = activity -> {:ok, activity}
	e -> e
	end
	end

	defp handle_incoming_normalized(%{"type" => type} = data, _options)
	when type in ~w{Like EmojiReact Announce Add Remove} 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

	defp handle_incoming_normalized(
	%{"type" => type} = data,
	_options
	)
	when type in ~w{Update Block Follow Accept Reject} do
	fixed_obj = maybe_fix_object(data["object"])
	data = if fixed_obj != nil, do: %{data \| "object" => fixed_obj}, else: data

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

	defp handle_incoming_normalized(
	%{"type" => "Delete"} = data,
	_options
	) do
	with {:ok, activity, _} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	{:error, {:validate, _}} = 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

	e ->
	{:error, e}
	end
	end

	defp handle_incoming_normalized(
	%{
	"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

	defp handle_incoming_normalized(
	%{
	"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.
	defp handle_incoming_normalized(
	%{
	"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_normalized(options)
	else
	_e -> :error
	end
	end

	defp handle_incoming_normalized(
	%{
	"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

	# Rewrite dislikes into the thumbs down emoji
	defp handle_incoming_normalized(%{"type" => "Dislike"} = data, options) do
	data
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", "👎")
	\|> handle_incoming_normalized(options)
	end

	defp handle_incoming_normalized(
	%{"type" => "Undo", "object" => %{"type" => "Dislike"}} = data,
	options
	) do
	data
	\|> put_in(["object", "type"], "EmojiReact")
	\|> put_in(["object", "content"], "👎")
	\|> handle_incoming_normalized(options)
	end

	defp handle_incoming_normalized(_, _), do: :error

	@spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} \| nil
	def get_obj_helper(id, options \\ []) do
	options = Keyword.put(options, :fetch, true)

	case Object.normalize(id, 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, fetch: false)}
	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 """
	Fedibird compatibility
	https://github.com/fedibird/mastodon/commit/dbd7ae6cf58a92ec67c512296b4daaea0d01e6ac
	"""
	def set_quote_url(%{"quoteUrl" => quote_url} = object) when is_binary(quote_url) do
	Map.put(object, "quoteUri", quote_url)
	end

	def set_quote_url(obj), do: obj

	@doc """
	Inline first page of the `replies` collection,
	containing any replies in chronological order.
	"""
	def set_replies(%{"type" => type} = obj_data)
	when type in Pleroma.Constants.status_object_types() do
	with obj_ap_id when is_binary(obj_ap_id) <- obj_data["id"],
	limit when limit > 0 <-
	Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
	collection <-
	Pleroma.Web.ActivityPub.ObjectView.render("object_replies.json", %{
	render_params: %{object_ap_id: obj_data["id"], limit: limit, skip_ap_ctx: true}
	}) do
	Map.put(obj_data, "replies", collection)
	else
	0 -> Map.put(obj_data, "replies", obj_data["id"] <> "/replies")
	_ -> obj_data
	end
	end

	def set_replies(obj_data), do: obj_data

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

	defp maybe_process_history(%{"formerRepresentations" => %{"orderedItems" => history}} = object) do
	processed_history =
	Enum.map(
	history,
	fn
	item when is_map(item) -> prepare_object(item)
	item -> item
	end
	)

	put_in(object, ["formerRepresentations", "orderedItems"], processed_history)
	end

	defp maybe_process_history(object) do
	object
	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(fetch: false)
	\|> Map.get(:data)

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

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => "Update", "object" => %{"type" => objtype} = object} = data)
	when objtype in Pleroma.Constants.updatable_object_types() do
	data =
	data
	\|> Map.put("object", prepare_object(object))
	\|> Map.merge(Utils.make_json_ld_header(object))
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => "Update", "object" => %{"type" => objtype} = object} = data)
	when objtype in Pleroma.Constants.actor_types() do
	object =
	object
	\|> maybe_fix_user_object()
	\|> strip_internal_fields()

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

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => "Update", "object" => %{}} = data) do
	raise "Requested to serve an Update for non-updateable object type: #{inspect(data)}"
	end

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

	data =
	if Visibility.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" => "Flag"} = data) do
	with {:ok, stripped_activity} <- Utils.strip_report_status_data(data),
	stripped_activity <- Utils.maybe_anonymize_reporter(stripped_activity),
	stripped_activity <- Map.merge(stripped_activity, Utils.make_json_ld_header()) do
	{:ok, stripped_activity}
	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(data))

	{: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, _} ->
	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)
	+ \|> Enum.map(&Emoji.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)
	+ out = Enum.map(emoji, &Emoji.build_emoji_tag/1)

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

	def add_emoji_tags(object), do: object

	- def build_emoji_tag({name, url}) do
	- url = URI.encode(url)
	-
	- %{
	- "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_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} = url \| _] = data["url"]

	%{
	"url" => href,
	"mediaType" => media_type,
	"name" => data["name"],
	"type" => "Document"
	}
	\|> Maps.put_if_present("width", url["width"])
	\|> Maps.put_if_present("height", url["height"])
	\|> Maps.put_if_present("blurhash", data["blurhash"])
	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 maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
	Map.put(data, "url", url["href"])
	end

	def maybe_fix_user_url(data), do: data

	def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
	index 03a2fc55a..d5f44676d 100644
	--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
	@@ -1,514 +1,527 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.FollowingRelationship
	alias Pleroma.User
	alias Pleroma.UserNote
	alias Pleroma.UserRelationship
	+ alias Pleroma.Utils.URIEncoding
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MediaProxy

	def render("index.json", %{users: users} = opts) do
	reading_user = opts[:for]

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

	is_nil(reading_user) \|\| !opts[:embed_relationships] ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	UserRelationship.view_relationships_option(reading_user, users)
	end

	opts =
	opts
	\|> Map.merge(%{relationships: relationships_opt, as: :user})
	\|> Map.delete(:users)

	users
	\|> render_many(AccountView, "show.json", opts)
	\|> Enum.filter(&Enum.any?/1)
	end

	@doc """
	Renders specified user account.
	:skip_visibility_check option skips visibility check and renders any user (local or remote)
	regardless of [:pleroma, :restrict_unauthenticated] setting.
	:for option specifies the requester and can be a User record or nil.
	Only use `user: user, for: user` when `user` is the actual requester of own profile.
	"""
	def render("show.json", %{user: _user, skip_visibility_check: true} = opts) do
	do_render("show.json", opts)
	end

	def render("show.json", %{user: user, for: for_user_or_nil} = opts) do
	if User.visible_for(user, for_user_or_nil) == :visible do
	do_render("show.json", opts)
	else
	%{}
	end
	end

	def render("show.json", _) do
	raise "In order to prevent account accessibility issues, " <>
	":skip_visibility_check or :for option is required."
	end

	def render("mention.json", %{user: user}) do
	%{
	id: to_string(user.id),
	acct: user.nickname,
	username: username_from_nickname(user.nickname),
	url: user.uri \|\| user.ap_id
	}
	end

	def render("relationship.json", %{user: nil, target: _target}) do
	%{}
	end

	def render(
	"relationship.json",
	%{user: %User{} = reading_user, target: %User{} = target} = opts
	) do
	user_relationships = get_in(opts, [:relationships, :user_relationships])
	following_relationships = get_in(opts, [:relationships, :following_relationships])

	follow_state =
	if following_relationships do
	user_to_target_following_relation =
	FollowingRelationship.find(following_relationships, reading_user, target)

	User.get_follow_state(reading_user, target, user_to_target_following_relation)
	else
	User.get_follow_state(reading_user, target)
	end

	followed_by = FollowingRelationship.following?(target, reading_user)
	following = FollowingRelationship.following?(reading_user, target)

	requested =
	cond do
	following -> false
	true -> match?(:follow_pending, follow_state)
	end

	subscribing =
	UserRelationship.exists?(
	user_relationships,
	:inverse_subscription,
	target,
	reading_user,
	&User.subscribed_to?(&2, &1)
	)

	# NOTE: adjust UserRelationship.view_relationships_option/2 on new relation-related flags
	%{
	id: to_string(target.id),
	following: following,
	followed_by: followed_by,
	blocking:
	UserRelationship.exists?(
	user_relationships,
	:block,
	reading_user,
	target,
	&User.blocks_user?(&1, &2)
	),
	blocked_by:
	UserRelationship.exists?(
	user_relationships,
	:block,
	target,
	reading_user,
	&User.blocks_user?(&1, &2)
	),
	muting:
	UserRelationship.exists?(
	user_relationships,
	:mute,
	reading_user,
	target,
	&User.mutes?(&1, &2)
	),
	muting_notifications:
	UserRelationship.exists?(
	user_relationships,
	:notification_mute,
	reading_user,
	target,
	&User.muted_notifications?(&1, &2)
	),
	subscribing: subscribing,
	notifying: subscribing,
	requested: requested,
	domain_blocking: User.blocks_domain?(reading_user, target),
	showing_reblogs:
	not UserRelationship.exists?(
	user_relationships,
	:reblog_mute,
	reading_user,
	target,
	&User.muting_reblogs?(&1, &2)
	),
	note:
	UserNote.show(
	reading_user,
	target
	),
	endorsed:
	UserRelationship.exists?(
	user_relationships,
	:endorsement,
	reading_user,
	target,
	&User.endorses?(&1, &2)
	)
	}
	end

	def render("relationships.json", %{user: user, targets: targets} = opts) do
	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

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

	true ->
	UserRelationship.view_relationships_option(user, targets)
	end

	render_opts = %{as: :target, user: user, relationships: relationships_opt}
	render_many(targets, AccountView, "relationship.json", render_opts)
	end

	def render("familiar_followers.json", %{users: users} = opts) do
	opts =
	opts
	\|> Map.merge(%{as: :user})
	\|> Map.delete(:users)

	users
	\|> render_many(AccountView, "familiar_followers.json", opts)
	end

	def render("familiar_followers.json", %{user: %{id: id, accounts: accounts}} = opts) do
	accounts =
	accounts
	\|> render_many(AccountView, "show.json", opts)
	\|> Enum.filter(&Enum.any?/1)

	%{id: id, accounts: accounts}
	end

	defp do_render("show.json", %{user: user} = opts) do
	self = opts[:for] == user

	user = User.sanitize_html(user, User.html_filter_policy(opts[:for]))
	display_name = user.name \|\| user.nickname

	avatar = User.avatar_url(user) \|> MediaProxy.url()
	avatar_static = User.avatar_url(user) \|> MediaProxy.preview_url(static: true)
	avatar_description = User.image_description(user.avatar)
	header = User.banner_url(user) \|> MediaProxy.url()
	header_static = User.banner_url(user) \|> MediaProxy.preview_url(static: true)
	header_description = User.image_description(user.banner)

	following_count =
	if !user.hide_follows_count or !user.hide_follows or self,
	do: user.following_count,
	else: 0

	followers_count =
	if !user.hide_followers_count or !user.hide_followers or self,
	do: user.follower_count,
	else: 0

	bot = bot?(user)

	emojis =
	Enum.map(user.emoji, fn {shortcode, raw_url} ->
	- url = MediaProxy.url(raw_url)
	+ url =
	+ raw_url
	+ \|> encode_emoji_url()
	+ \|> MediaProxy.url()

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

	relationship =
	if opts[:embed_relationships] do
	render("relationship.json", %{
	user: opts[:for],
	target: user,
	relationships: opts[:relationships]
	})
	else
	%{}
	end

	favicon =
	if Pleroma.Config.get([:instances_favicons, :enabled]) do
	user
	\|> Map.get(:ap_id, "")
	\|> URI.parse()
	\|> URI.merge("/")
	\|> Pleroma.Instances.Instance.get_or_update_favicon()
	\|> MediaProxy.url()
	else
	nil
	end

	last_status_at =
	user.last_status_at &&
	user.last_status_at \|> NaiveDateTime.to_date() \|> Date.to_iso8601()

	%{
	id: to_string(user.id),
	username: username_from_nickname(user.nickname),
	acct: user.nickname,
	display_name: display_name,
	locked: user.is_locked,
	created_at: Utils.to_masto_date(user.inserted_at),
	followers_count: followers_count,
	following_count: following_count,
	statuses_count: user.note_count,
	note: user.bio,
	url: user.uri \|\| user.ap_id,
	avatar: avatar,
	avatar_static: avatar_static,
	header: header,
	header_static: header_static,
	emojis: emojis,
	fields: user.fields,
	bot: bot,
	source: %{
	note: user.raw_bio \|\| "",
	sensitive: false,
	fields: user.raw_fields,
	pleroma: %{
	discoverable: user.is_discoverable,
	actor_type: user.actor_type
	}
	},
	last_status_at: last_status_at,

	# Pleroma extensions
	# Note: it's insecure to output :email but fully-qualified nickname may serve as safe stub
	fqn: User.full_nickname(user),
	pleroma: %{
	ap_id: user.ap_id,
	also_known_as: user.also_known_as,
	is_confirmed: user.is_confirmed,
	is_suggested: user.is_suggested,
	tags: user.tags,
	hide_followers_count: user.hide_followers_count,
	hide_follows_count: user.hide_follows_count,
	hide_followers: user.hide_followers,
	hide_follows: user.hide_follows,
	hide_favorites: user.hide_favorites,
	relationship: relationship,
	skip_thread_containment: user.skip_thread_containment,
	background_image: image_url(user.background) \|> MediaProxy.url(),
	accepts_chat_messages: user.accepts_chat_messages,
	favicon: favicon,
	avatar_description: avatar_description,
	header_description: header_description
	}
	}
	\|> maybe_put_role(user, opts[:for])
	\|> maybe_put_settings(user, opts[:for], opts)
	\|> maybe_put_notification_settings(user, opts[:for])
	\|> maybe_put_settings_store(user, opts[:for], opts)
	\|> maybe_put_chat_token(user, opts[:for], opts)
	\|> maybe_put_activation_status(user, opts[:for])
	\|> maybe_put_follow_requests_count(user, opts[:for])
	\|> maybe_put_allow_following_move(user, opts[:for])
	\|> maybe_put_unread_conversation_count(user, opts[:for])
	\|> maybe_put_unread_notification_count(user, opts[:for])
	\|> maybe_put_email_address(user, opts[:for])
	\|> maybe_put_mute_expires_at(user, opts[:for], opts)
	\|> maybe_put_block_expires_at(user, opts[:for], opts)
	\|> maybe_show_birthday(user, opts[:for])
	end

	defp username_from_nickname(string) when is_binary(string) do
	hd(String.split(string, "@"))
	end

	defp username_from_nickname(_), do: nil

	defp maybe_put_follow_requests_count(
	data,
	%User{id: user_id} = user,
	%User{id: user_id}
	) do
	count =
	User.get_follow_requests(user)
	\|> length()

	data
	\|> Kernel.put_in([:follow_requests_count], count)
	end

	defp maybe_put_follow_requests_count(data, _, _), do: data

	defp maybe_put_settings(
	data,
	%User{id: user_id} = user,
	%User{id: user_id},
	_opts
	) do
	data
	\|> Kernel.put_in([:source, :privacy], user.default_scope)
	\|> Kernel.put_in([:source, :pleroma, :show_role], user.show_role)
	\|> Kernel.put_in([:source, :pleroma, :no_rich_text], user.no_rich_text)
	\|> Kernel.put_in([:source, :pleroma, :show_birthday], user.show_birthday)
	end

	defp maybe_put_settings(data, _, _, _), do: data

	defp maybe_put_settings_store(data, %User{} = user, %User{}, %{
	with_pleroma_settings: true
	}) do
	data
	\|> Kernel.put_in([:pleroma, :settings_store], user.pleroma_settings_store)
	end

	defp maybe_put_settings_store(data, _, _, _), do: data

	defp maybe_put_chat_token(data, %User{id: id}, %User{id: id}, %{
	with_chat_token: token
	}) do
	data
	\|> Kernel.put_in([:pleroma, :chat_token], token)
	end

	defp maybe_put_chat_token(data, _, _, _), do: data

	defp maybe_put_role(data, %User{show_role: true} = user, _) do
	put_role(data, user)
	end

	defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
	put_role(data, user)
	end

	defp maybe_put_role(data, _, _), do: data

	defp put_role(data, user) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
	\|> Kernel.put_in([:pleroma, :privileges], User.privileges(user))
	end

	defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
	Kernel.put_in(
	data,
	[:pleroma, :notification_settings],
	Map.from_struct(user.notification_settings)
	)
	end

	defp maybe_put_notification_settings(data, _, _), do: data

	defp maybe_put_allow_following_move(data, %User{id: user_id} = user, %User{id: user_id}) do
	Kernel.put_in(data, [:pleroma, :allow_following_move], user.allow_following_move)
	end

	defp maybe_put_allow_following_move(data, _, _), do: data

	defp maybe_put_activation_status(data, user, user_for) do
	if User.privileged?(user_for, :users_manage_activation_state),
	do: Kernel.put_in(data, [:pleroma, :deactivated], !user.is_active),
	else: data
	end

	defp maybe_put_unread_conversation_count(data, %User{id: user_id} = user, %User{id: user_id}) do
	data
	\|> Kernel.put_in(
	[:pleroma, :unread_conversation_count],
	Pleroma.Conversation.Participation.unread_count(user)
	)
	end

	defp maybe_put_unread_conversation_count(data, _, _), do: data

	defp maybe_put_unread_notification_count(data, %User{id: user_id}, %User{id: user_id} = user) do
	Kernel.put_in(
	data,
	[:pleroma, :unread_notifications_count],
	Pleroma.Notification.unread_notifications_count(user)
	)
	end

	defp maybe_put_unread_notification_count(data, _, _), do: data

	defp maybe_put_email_address(data, %User{id: user_id}, %User{id: user_id} = user) do
	Kernel.put_in(
	data,
	[:pleroma, :email],
	user.email
	)
	end

	defp maybe_put_email_address(data, _, _), do: data

	defp maybe_put_mute_expires_at(data, %User{} = user, target, %{mutes: true}) do
	Map.put(
	data,
	:mute_expires_at,
	UserRelationship.get_mute_expire_date(target, user)
	)
	end

	defp maybe_put_mute_expires_at(data, _, _, _), do: data

	defp maybe_put_block_expires_at(data, %User{} = user, target, %{blocks: true}) do
	Map.put(
	data,
	:block_expires_at,
	UserRelationship.get_block_expire_date(target, user)
	)
	end

	defp maybe_put_block_expires_at(data, _, _, _), do: data

	defp maybe_show_birthday(data, %User{id: user_id} = user, %User{id: user_id}) do
	data
	\|> Kernel.put_in([:pleroma, :birthday], user.birthday)
	end

	defp maybe_show_birthday(data, %User{show_birthday: true} = user, _) do
	data
	\|> Kernel.put_in([:pleroma, :birthday], user.birthday)
	end

	defp maybe_show_birthday(data, _, _) do
	data
	end

	defp image_url(%{"url" => [%{"href" => href} \| _]}), do: href
	defp image_url(_), do: nil

	defp bot?(user) do
	# Because older and/or Mastodon clients may not recognize a Group actor properly,
	# and currently the group actor can only boost things, we should let these clients
	# think groups are bots.
	# See https://git.pleroma.social/pleroma/pleroma-meta/-/issues/14
	user.actor_type == "Service" \|\| user.actor_type == "Group"
	end
	+
	+ defp encode_emoji_url(nil), do: nil
	+ defp encode_emoji_url("http" <> _ = url), do: URIEncoding.encode_url(url)
	+
	+ defp encode_emoji_url("/" <> _ = path),
	+ do: URIEncoding.encode_url(path, bypass_parse: true, bypass_decode: true)
	+
	+ defp encode_emoji_url(path) when is_binary(path),
	+ do: URIEncoding.encode_url(path, bypass_parse: true, bypass_decode: true)
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex b/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	index cd59ab946..6ef48e98a 100644
	--- a/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	@@ -1,28 +1,27 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Emoji
	- alias Pleroma.Web.Endpoint

	def render("index.json", %{custom_emojis: custom_emojis}) do
	render_many(custom_emojis, __MODULE__, "show.json")
	end

	def render("show.json", %{custom_emoji: {shortcode, %Emoji{file: relative_url, tags: tags}}}) do
	- url = Endpoint.url() \|> URI.merge(relative_url) \|> to_string()
	+ url = Emoji.local_url(relative_url)

	%{
	"shortcode" => shortcode,
	"static_url" => url,
	"visible_in_picker" => true,
	"url" => url,
	"tags" => tags,
	# Assuming that a comma is authorized in the category name
	"category" => tags \|> List.delete("Custom") \|> Enum.join(",")
	}
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/views/bookmark_folder_view.ex b/lib/pleroma/web/pleroma_api/views/bookmark_folder_view.ex
	index 12decb816..29028781f 100644
	--- a/lib/pleroma/web/pleroma_api/views/bookmark_folder_view.ex
	+++ b/lib/pleroma/web/pleroma_api/views/bookmark_folder_view.ex
	@@ -1,42 +1,41 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.BookmarkFolder
	alias Pleroma.Emoji
	- alias Pleroma.Web.Endpoint

	def render("show.json", %{folder: %BookmarkFolder{} = folder}) do
	%{
	id: folder.id \|> to_string(),
	name: folder.name,
	emoji: folder.emoji,
	emoji_url: get_emoji_url(folder.emoji)
	}
	end

	def render("index.json", %{folders: folders} = opts) do
	render_many(folders, __MODULE__, "show.json", Map.delete(opts, :folders))
	end

	defp get_emoji_url(nil) do
	nil
	end

	defp get_emoji_url(emoji) do
	if Emoji.unicode?(emoji) do
	nil
	else
	emoji = Emoji.get(emoji)

	if emoji != nil do
	- Endpoint.url() \|> URI.merge(emoji.file) \|> to_string()
	+ Emoji.local_url(emoji.file)
	else
	nil
	end
	end
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index aeafa195d..1c072f98a 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,396 +1,407 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilController do
	use Pleroma.Web, :controller

	require Logger

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Emoji
	alias Pleroma.Healthcheck
	alias Pleroma.User
	+ alias Pleroma.Utils.URIEncoding
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.Auth.WrapperAuthenticator, as: Authenticator
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.WebFinger

	plug(
	Pleroma.Web.ApiSpec.CastAndValidate,
	[replace_params: false]
	when action != :remote_subscribe and action != :show_subscribe_form
	)

	plug(
	Pleroma.Web.Plugs.FederatingPlug
	when action == :remote_subscribe
	when action == :show_subscribe_form
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:accounts"]}
	when action in [
	:change_email,
	:change_password,
	:delete_account,
	:update_notification_settings,
	:disable_account,
	:move_account,
	:add_alias,
	:delete_alias
	]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:accounts"]}
	when action in [
	:list_aliases
	]
	)

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

	def show_subscribe_form(conn, %{"nickname" => nick}) do
	with %User{} = user <- User.get_cached_by_nickname(nick),
	avatar = User.avatar_url(user) do
	conn
	\|> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"remote follow error message - user not found",
	"Could not find user"
	)
	})
	end
	end

	def show_subscribe_form(conn, %{"status_id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	{:ok, ap_id} <- get_ap_id(activity),
	%User{} = user <- User.get_cached_by_ap_id(activity.actor),
	avatar = User.avatar_url(user) do
	conn
	\|> render("status_interact.html", %{
	status_link: ap_id,
	status_id: id,
	nickname: user.nickname,
	avatar: avatar,
	error: false
	})
	else
	_e ->
	render(conn, "status_interact.html", %{
	status_id: id,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"status interact error message - status not found",
	"Could not find status"
	)
	})
	end
	end

	def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
	show_subscribe_form(conn, %{"nickname" => nick})
	end

	def remote_subscribe(conn, %{"status_id" => id, "profile" => _}) do
	show_subscribe_form(conn, %{"status_id" => id})
	end

	def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"remote follow error message - unknown error",
	"Something went wrong."
	)
	})
	end
	end

	def remote_subscribe(conn, %{"status" => %{"status_id" => id, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%Activity{} = activity <- Activity.get_by_id(id),
	{:ok, ap_id} <- get_ap_id(activity) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "status_interact.html", %{
	status_id: id,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"status interact error message - unknown error",
	"Something went wrong."
	)
	})
	end
	end

	def remote_interaction(
	%{private: %{open_api_spex: %{body_params: %{ap_id: ap_id, profile: profile}}}} = conn,
	_params
	) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile) do
	conn
	\|> json(%{url: String.replace(template, "{uri}", ap_id)})
	else
	_e -> json(conn, %{error: "Couldn't find user"})
	end
	end

	defp get_ap_id(activity) do
	object = Pleroma.Object.normalize(activity, fetch: false)

	case object do
	%{data: %{"id" => ap_id}} -> {:ok, ap_id}
	_ -> {:no_ap_id, nil}
	end
	end

	def frontend_configurations(conn, _params) do
	render(conn, "frontend_configurations.json")
	end

	def emoji(conn, _params) do
	emoji =
	Enum.reduce(Emoji.get_all(), %{}, fn {code, %Emoji{file: file, tags: tags}}, acc ->
	+ file = encode_emoji_url(file)
	Map.put(acc, code, %{image_url: file, tags: tags})
	end)

	json(conn, emoji)
	end

	+ defp encode_emoji_url(nil), do: nil
	+ defp encode_emoji_url("http" <> _ = url), do: URIEncoding.encode_url(url)
	+
	+ defp encode_emoji_url("/" <> _ = path),
	+ do: URIEncoding.encode_url(path, bypass_parse: true, bypass_decode: true)
	+
	+ defp encode_emoji_url(path) when is_binary(path),
	+ do: URIEncoding.encode_url(path, bypass_parse: true, bypass_decode: true)
	+
	def update_notification_settings(%{assigns: %{user: user}} = conn, params) do
	with {:ok, _} <- User.update_notification_settings(user, params) do
	json(conn, %{status: "success"})
	end
	end

	def change_password(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	with {:ok, %User{}} <-
	Authenticator.change_password(
	user,
	body_params.password,
	body_params.new_password,
	body_params.new_password_confirmation
	) do
	json(conn, %{status: "success"})
	else
	{:error, %Ecto.Changeset{} = changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "New password #{error}."})

	{:error, :password_confirmation} ->
	json(conn, %{error: "New password does not match confirmation."})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def change_email(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, _user} <- User.change_email(user, body_params.email) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "Email #{error}."})

	_ ->
	json(conn, %{error: "Unable to change email."})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def delete_account(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: body_params, params: params}}
	} = conn,
	_
	) do
	# This endpoint can accept a query param or JSON body for backwards-compatibility.
	# Submitting a JSON body is recommended, so passwords don't end up in server logs.
	password = body_params[:password] \|\| params[:password] \|\| ""

	case CommonAPI.Utils.confirm_current_password(user, password) do
	{:ok, user} ->
	User.delete(user)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def disable_account(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: params}}} = conn,
	_
	) do
	case CommonAPI.Utils.confirm_current_password(user, params[:password]) do
	{:ok, user} ->
	User.set_activation_async(user, false)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def move_account(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, target_user} <- find_or_fetch_user_by_nickname(body_params.target_account),
	{:ok, _user} <- ActivityPub.move(user, target_user) do
	json(conn, %{status: "success"})
	else
	{:not_found, _} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Target account not found."})

	{:error, error} ->
	json(conn, %{error: error})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def add_alias(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	with {:ok, alias_user} <- find_user_by_nickname(body_params.alias),
	{:ok, _user} <- user \|> User.add_alias(alias_user) do
	json(conn, %{status: "success"})
	else
	{:not_found, _} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Target account does not exist."})

	{:error, error} ->
	json(conn, %{error: error})
	end
	end

	def delete_alias(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	with {:ok, alias_user} <- find_user_by_nickname(body_params.alias),
	{:ok, _user} <- user \|> User.delete_alias(alias_user) do
	json(conn, %{status: "success"})
	else
	{:error, :no_such_alias} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Account has no such alias."})

	{:error, error} ->
	json(conn, %{error: error})
	end
	end

	def list_aliases(%{assigns: %{user: user}} = conn, _) do
	alias_nicks =
	user
	\|> User.alias_users()
	\|> Enum.map(&User.full_nickname/1)

	json(conn, %{aliases: alias_nicks})
	end

	defp find_user_by_nickname(nickname) do
	user = User.get_cached_by_nickname(nickname)

	if user == nil do
	{:error, :not_found}
	else
	{:ok, user}
	end
	end

	defp find_or_fetch_user_by_nickname(nickname) do
	user = User.get_by_nickname(nickname)

	if user != nil and user.local do
	{:ok, user}
	else
	with {:ok, user} <- User.fetch_by_nickname(nickname) do
	{:ok, user}
	else
	_ ->
	{:not_found, nil}
	end
	end
	end

	def captcha(conn, _params) do
	json(conn, Pleroma.Captcha.new())
	end

	def healthcheck(conn, _params) do
	with {:cfg, true} <- {:cfg, Config.get([:instance, :healthcheck])},
	%{healthy: true} = info <- Healthcheck.system_info() do
	json(conn, info)
	else
	%{healthy: false} = info ->
	service_unavailable(conn, info)

	{:cfg, false} ->
	service_unavailable(conn, %{"error" => "Healthcheck disabled"})

	_ ->
	service_unavailable(conn, %{})
	end
	end

	defp service_unavailable(conn, info) do
	conn
	\|> put_status(:service_unavailable)
	\|> json(info)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/emoji_tag_building_test.exs b/test/pleroma/web/activity_pub/transmogrifier/emoji_tag_building_test.exs
	index c632c199c..b91658ce4 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/emoji_tag_building_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/emoji_tag_building_test.exs
	@@ -1,14 +1,46 @@
	defmodule Pleroma.Web.ActivityPub.Transmogrifier.EmojiTagBuildingTest do
	use Pleroma.DataCase, async: true

	- alias Pleroma.Web.ActivityPub.Transmogrifier
	-
	test "it encodes the id to be a valid url" do
	name = "hanapog"
	url = "https://misskey.local.live/emojis/hana pog.png"

	- tag = Transmogrifier.build_emoji_tag({name, url})
	+ tag = Pleroma.Emoji.build_emoji_tag({name, url})

	assert tag["id"] == "https://misskey.local.live/emojis/hana%20pog.png"
	end
	+
	+ test "it does not double-encode already encoded urls" do
	+ name = "hanapog"
	+ url = "https://misskey.local.live/emojis/hana%20pog.png"
	+
	+ tag = Pleroma.Emoji.build_emoji_tag({name, url})
	+
	+ assert tag["id"] == url
	+ end
	+
	+ test "it encodes disallowed path characters" do
	+ name = "hanapog"
	+ url = "https://example.com/emojis/hana[pog].png"
	+
	+ tag = Pleroma.Emoji.build_emoji_tag({name, url})
	+
	+ assert tag["id"] == "https://example.com/emojis/hana%5Bpog%5D.png"
	+ end
	+
	+ test "local_url does not decode percent in filenames" do
	+ url = Pleroma.Emoji.local_url("/emoji/hana%20pog.png")
	+
	+ assert url == Pleroma.Web.Endpoint.url() <> "/emoji/hana%2520pog.png"
	+
	+ tag = Pleroma.Emoji.build_emoji_tag({"hanapog", url})
	+
	+ assert tag["id"] == url
	+ end
	+
	+ test "local_url encodes question marks in filenames" do
	+ url = Pleroma.Emoji.local_url("/emoji/file?name.png")
	+
	+ assert url == Pleroma.Web.Endpoint.url() <> "/emoji/file%3Fname.png"
	+ end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier_test.exs b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	index 6dc4423fa..b54196a3c 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier_test.exs
	@@ -1,1103 +1,1119 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Mock
	import Pleroma.Factory
	import ExUnit.CaptureLog

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

	setup do: clear_config([:instance, :max_remote_account_fields])

	describe "handle_incoming" do
	test "it works for incoming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", user.ap_id)

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

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Jason.decode!()
	\|> Map.put("object", follow_data)

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

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "test post"})
	object = Object.normalize(activity, fetch: false)

	note_obj = %{
	"type" => "Note",
	"id" => activity.object.data["id"],
	"content" => "test post",
	"published" => object.data["published"],
	"actor" => AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	}

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, activity.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	assert activity.data["object"] == [user.ap_id, note_obj]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end

	test "it accepts Move activities" do
	old_user = insert(:user)
	new_user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Move",
	"actor" => old_user.ap_id,
	"object" => old_user.ap_id,
	"target" => new_user.ap_id
	}

	assert :error = Transmogrifier.handle_incoming(message)

	{:ok, _new_user} = User.update_and_set_cache(new_user, %{also_known_as: [old_user.ap_id]})

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(message)
	assert activity.actor == old_user.ap_id
	assert activity.data["actor"] == old_user.ap_id
	assert activity.data["object"] == old_user.ap_id
	assert activity.data["target"] == new_user.ap_id
	assert activity.data["type"] == "Move"
	end

	test "it fixes both the Create and object contexts in a reply" do
	insert(:user, ap_id: "https://mk.absturztau.be/users/8ozbzjs3o8")
	insert(:user, ap_id: "https://p.helene.moe/users/helene")

	create_activity =
	"test/fixtures/create-pleroma-reply-to-misskey-thread.json"
	\|> File.read!()
	\|> Jason.decode!()

	assert {:ok, %Activity{} = activity} = Transmogrifier.handle_incoming(create_activity)

	object = Object.normalize(activity, fetch: false)

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

	test "it fixes the public scope addressing" do
	insert(:user,
	ap_id: "https://mymath.rocks/endpoints/SYn3cl_N4HAPfPHgo2x37XunLEmhV9LnxCggcYwyec0"
	)

	object =
	"test/fixtures/bovine-bogus-public-note.json"
	\|> File.read!()
	\|> Jason.decode!()

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => "https://mymath.rocks/endpoints/SYn3cl_N4HAPfPHgo2x37XunLEmhV9LnxCggcYwyec0",
	"object" => object
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	object = Object.normalize(activity, fetch: false)
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in object.data["to"]
	end

	test "it keeps link tags" do
	insert(:user, ap_id: "https://example.org/users/alice")

	message = File.read!("test/fixtures/fep-e232.json") \|> Jason.decode!()

	assert capture_log(fn ->
	assert {:ok, activity} = Transmogrifier.handle_incoming(message)
	object = Object.normalize(activity)
	assert [%{"type" => "Mention"}, %{"type" => "Link"}] = object.data["tag"]
	end) =~ "Object rejected while fetching"
	end

	test "it accepts quote posts" do
	insert(:user, ap_id: "https://misskey.io/users/7rkrarq81i")

	object = File.read!("test/fixtures/quote_post/misskey_quote_post.json") \|> Jason.decode!()

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => "https://misskey.io/users/7rkrarq81i",
	"object" => object
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	# Object was created in the database
	object = Object.normalize(activity)
	assert object.data["quoteUrl"] == "https://misskey.io/notes/8vs6wxufd0"

	# It fetched the quoted post
	assert Object.normalize("https://misskey.io/notes/8vs6wxufd0")
	end

	test "doesn't allow remote edits to fake local likes" do
	# as a spot check for no internal fields getting injected
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	local_user = insert(:user)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => [local_user.ap_id]
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0
	end

	test "strips internal fields from history items in edited notes" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	local_user = insert(:user)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/2619539638",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => [],
	"like_count" => 0
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [
	Map.merge(create_data["object"], %{
	"likes" => [local_user.ap_id],
	"like_count" => 1,
	"pleroma" => %{"internal_field" => "should_be_stripped"}
	})
	]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	# Check that internal fields are stripped from history items
	history_item = List.first(object.data["formerRepresentations"]["orderedItems"])
	assert history_item["likes"] == []
	assert history_item["like_count"] == 0
	refute Map.has_key?(history_item, "pleroma")
	end

	test "doesn't trip over remote likes in notes" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "miaow",
	"likes" => %{
	"id" => "http://mastodon.example.org/users/admin/statuses/3409297097/likes",
	"totalItems" => 0,
	"type" => "Collection"
	}
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "miaow :3")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "likes", "totalItems"], 666)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "miaow"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "miaow :3"
	assert object.data["likes"] == []
	# in the future this should retain remote likes, but for now:
	assert object.data["like_count"] == 0
	end

	test "doesn't trip over remote likes in polls" do
	now = DateTime.utc_now()
	pub_date = DateTime.to_iso8601(Timex.subtract(now, Timex.Duration.from_minutes(3)))
	edit_date = DateTime.to_iso8601(now)

	create_data = %{
	"type" => "Create",
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073/activity",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"object" => %{
	"type" => "Question",
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073",
	"attributedTo" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"published" => pub_date,
	"content" => "vote!",
	"anyOf" => [
	%{
	"type" => "Note",
	"name" => "a",
	"replies" => %{
	"type" => "Collection",
	"totalItems" => 3
	}
	},
	%{
	"type" => "Note",
	"name" => "b",
	"replies" => %{
	"type" => "Collection",
	"totalItems" => 1
	}
	}
	],
	"likes" => %{
	"id" => "http://mastodon.example.org/users/admin/statuses/2471790073/likes",
	"totalItems" => 0,
	"type" => "Collection"
	}
	}
	}

	update_data =
	create_data
	\|> Map.put("type", "Update")
	\|> Map.put("id", create_data["object"]["id"] <> "/update/1")
	\|> put_in(["object", "content"], "vote now!")
	\|> put_in(["object", "updated"], edit_date)
	\|> put_in(["object", "likes", "totalItems"], 666)
	\|> put_in(["object", "formerRepresentations"], %{
	"type" => "OrderedCollection",
	"totalItems" => 1,
	"orderedItems" => [create_data["object"]]
	})

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(create_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["content"] == "vote!"
	assert object.data["likes"] == []
	assert object.data["like_count"] == 0

	{:ok, %Pleroma.Activity{} = activity} = Transmogrifier.handle_incoming(update_data)
	%Pleroma.Object{} = object = Object.get_by_ap_id(activity.data["object"]["id"])
	assert object.data["content"] == "vote now!"
	assert object.data["likes"] == []
	# in the future this should retain remote likes, but for now:
	assert object.data["like_count"] == 0
	end
	end

	describe "prepare outgoing" do
	test "it inlines private announced objects" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey", visibility: "private"})

	{:ok, announce_activity} = CommonAPI.repeat(activity.id, user)

	{:ok, modified} = Transmogrifier.prepare_outgoing(announce_activity.data)

	assert modified["object"]["content"] == "hey"
	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{status: "hey, @#{other_user.nickname}, how are ya? #2hu"})

	with_mock Pleroma.Notification,
	get_notified_from_activity: fn _, _ -> [] end do
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	refute called(Pleroma.Notification.get_notified_from_activity(:_, :_))
	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["@context"] == Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

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

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "#2hu :firefox:",
	generator: %{type: "Application", name: "TestClient", url: "https://pleroma.social"}
	})

	# Ensure injected application data made it into the activity
	# as we don't have a Token to derive it from, otherwise it will
	# be nil and the test will pass
	assert %{
	type: "Application",
	name: "TestClient",
	url: "https://pleroma.social"
	} == activity.object.data["generator"]

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["generator"])
	assert is_nil(modified["object"]["rules"])
	assert is_nil(modified["object"]["language"])
	assert is_nil(modified["object"]["voters"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["likes"])
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "2hu :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} = CommonAPI.post(user, %{status: "@#{other_user.nickname} :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} :moominmamma:",
	visibility: "direct"
	})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == true
	end

	test "it strips BCC field" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert is_nil(modified["bcc"])
	end

	test "it can handle Listen activities" do
	listen_activity = insert(:listen)

	# This has an inlined object as in ObjectView
	{:ok, modified} = Transmogrifier.prepare_outgoing(listen_activity.data)

	assert modified["type"] == "Listen"

	user = insert(:user)

	{:ok, activity} = CommonAPI.listen(user, %{"title" => "lain radio episode 1"})

	user_ap_id = user.ap_id
	activity_ap_id = activity.data["id"]
	activity_to = activity.data["to"]
	activity_cc = activity.data["cc"]
	object_ap_id = activity.data["object"]
	object_type = activity.object.data["type"]

	# This does not have an inlined object
	{:ok, modified2} = Transmogrifier.prepare_outgoing(activity.data)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "Listen",
	"actor" => ^user_ap_id,
	"to" => ^activity_to,
	"cc" => ^activity_cc,
	"context" => "http://localhost" <> _,
	"id" => ^activity_ap_id,
	"object" => %{
	"actor" => ^user_ap_id,
	"attributedTo" => ^user_ap_id,
	"id" => ^object_ap_id,
	"type" => ^object_type,
	"to" => ^activity_to,
	"cc" => ^activity_cc
	}
	},
	modified2
	)
	end

	test "custom emoji urls are URI encoded" do
	# :dinosaur: filename has a space -> dino walking.gif
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})

	{:ok, prepared} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(prepared["object"]["tag"]) == 1

	url = prepared["object"]["tag"] \|> List.first() \|> Map.get("icon") \|> Map.get("url")

	assert url == "http://localhost:4001/emoji/dino%20walking.gif"
	end

	test "Updates of Notes are handled" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "everybody do the dinosaur :dinosaur:"})
	{:ok, update} = CommonAPI.update(activity, user, %{status: "mew mew :blank:"})

	{:ok, prepared} = Transmogrifier.prepare_outgoing(update.data)

	assert %{
	"content" => "mew mew :blank:",
	"tag" => [%{"name" => ":blank:", "type" => "Emoji"}],
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"content" => "everybody do the dinosaur :dinosaur:",
	"tag" => [%{"name" => ":dinosaur:", "type" => "Emoji"}]
	}
	]
	}
	} = prepared["object"]
	end

	test "Updates of Actors are handled" do
	user = insert(:user, local: true)

	changeset = User.update_changeset(user, %{name: "new name"})
	{:ok, unpersisted_user} = Ecto.Changeset.apply_action(changeset, :update)

	updated_object =
	UserView.render("user.json", user: unpersisted_user)
	\|> Map.delete("@context")

	{:ok, update_data, []} = Builder.update(user, updated_object)

	{:ok, activity, _} =
	Pipeline.common_pipeline(update_data,
	local: true,
	user_update_changeset: changeset
	)

	assert {:ok, prepared} = Transmogrifier.prepare_outgoing(activity.data)
	assert prepared["type"] == "Update"
	assert prepared["@context"]
	assert prepared["object"]["type"] == user.actor_type
	end

	test "Correctly handles Undo activities" do
	blocked = insert(:user)
	blocker = insert(:user, local: true)

	blocked_ap_id = blocked.ap_id
	blocker_ap_id = blocker.ap_id

	{:ok, %Activity{} = block_activity} = CommonAPI.block(blocked, blocker)
	{:ok, %Activity{} = undo_activity} = CommonAPI.unblock(blocked, blocker)
	{:ok, data} = Transmogrifier.prepare_outgoing(undo_activity.data)

	block_ap_id = block_activity.data["id"]
	assert is_binary(block_ap_id)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "Undo",
	"id" => "http://localhost" <> _,
	"actor" => ^blocker_ap_id,
	"object" => ^block_ap_id,
	"to" => [^blocked_ap_id],
	"cc" => [],
	"bto" => [],
	"bcc" => []
	},
	data
	)
	end

	test "Correctly handles EmojiReact activities" do
	user = insert(:user, local: true)
	note_activity = insert(:note_activity)

	user_ap_id = user.ap_id
	user_followers = user.follower_address
	note_author = note_activity.data["actor"]
	note_ap_id = note_activity.data["object"]

	assert is_binary(note_author)
	assert is_binary(note_ap_id)

	{:ok, react_activity} = CommonAPI.react_with_emoji(note_activity.id, user, "🐈")
	{:ok, data} = Transmogrifier.prepare_outgoing(react_activity.data)

	assert match?(
	%{
	"@context" => [_ \| _],
	"type" => "EmojiReact",
	"actor" => ^user_ap_id,
	"to" => [^user_followers, ^note_author],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"bto" => [],
	"bcc" => [],
	"content" => "🐈",
	"context" => "2hu",
	"id" => "http://localhost" <> _,
	"object" => ^note_ap_id,
	"tag" => []
	},
	data
	)
	end

	+ test "EmojiReact custom emoji urls are URI encoded" do
	+ user = insert(:user, local: true)
	+ note_activity = insert(:note_activity)
	+
	+ {:ok, react_activity} = CommonAPI.react_with_emoji(note_activity.id, user, ":dinosaur:")
	+ {:ok, data} = Transmogrifier.prepare_outgoing(react_activity.data)
	+
	+ assert length(data["tag"]) == 1
	+
	+ tag = List.first(data["tag"])
	+ url = tag["icon"]["url"]
	+
	+ assert url == "http://localhost:4001/emoji/dino%20walking.gif"
	+ assert tag["id"] == "http://localhost:4001/emoji/dino%20walking.gif"
	+ end
	+
	test "it prepares a quote post" do
	user = insert(:user)

	{:ok, quoted_post} = CommonAPI.post(user, %{status: "hey"})
	{:ok, quote_post} = CommonAPI.post(user, %{status: "hey", quoted_status_id: quoted_post.id})

	{:ok, modified} = Transmogrifier.prepare_outgoing(quote_post.data)

	%{data: %{"id" => quote_id}} = Object.normalize(quoted_post)

	assert modified["object"]["quoteUrl"] == quote_id
	assert modified["object"]["quoteUri"] == quote_id
	end

	test "it adds language of the object to its json-ld context" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.object.data)

	assert [_, _, %{"@language" => "pl"}] = modified["@context"]
	end

	test "it adds language of the object to Create activity json-ld context" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert [_, _, %{"@language" => "pl"}] = modified["@context"]
	end

	test "it strips report data" do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, reported_activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	object_ap_id = reported_activity.object.data["id"]

	assert {:ok, activity} =
	Pleroma.Web.ActivityPub.ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)

	expected_data =
	activity.data
	\|> put_in(["object"], [target_account.ap_id, object_ap_id])
	\|> Map.put("actor", reporter.ap_id)
	\|> Map.merge(Utils.make_json_ld_header())

	assert data == expected_data
	end

	test "it strips report data and anonymize" do
	placeholder = insert(:user)

	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, reported_activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	object_ap_id = reported_activity.object.data["id"]

	assert {:ok, activity} =
	Pleroma.Web.ActivityPub.ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)

	expected_data =
	activity.data
	\|> put_in(["object"], [target_account.ap_id, object_ap_id])
	\|> Map.put("actor", placeholder.ap_id)
	\|> Map.merge(Utils.make_json_ld_header())

	assert data == expected_data
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	assert capture_log(fn ->
	{:error, _} = Transmogrifier.handle_incoming(data)
	end) =~ "Object rejected while fetching"
	end
	end

	describe "fix_explicit_addressing" do
	setup do
	user = insert(:user)
	[user: user]
	end

	test "moves non-explicitly mentioned actors to cc", %{user: user} do
	explicitly_mentioned_actors = [
	"https://pleroma.gold/users/user1",
	"https://pleroma.gold/user2"
	]

	object = %{
	"actor" => user.ap_id,
	"to" => explicitly_mentioned_actors ++ ["https://social.beepboop.ga/users/dirb"],
	"cc" => [],
	"tag" =>
	Enum.map(explicitly_mentioned_actors, fn href ->
	%{"type" => "Mention", "href" => href}
	end)
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert Enum.all?(explicitly_mentioned_actors, &(&1 in fixed_object["to"]))
	refute "https://social.beepboop.ga/users/dirb" in fixed_object["to"]
	assert "https://social.beepboop.ga/users/dirb" in fixed_object["cc"]
	end

	test "does not move actor's follower collection to cc", %{user: user} do
	object = %{
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => []
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)
	assert user.follower_address in fixed_object["to"]
	refute user.follower_address in fixed_object["cc"]
	end

	test "removes recipient's follower collection from cc", %{user: user} do
	recipient = insert(:user)

	object = %{
	"actor" => user.ap_id,
	"to" => [recipient.ap_id, "https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address, recipient.follower_address]
	}

	fixed_object = Transmogrifier.fix_explicit_addressing(object, user.follower_address)

	assert user.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["cc"]
	refute recipient.follower_address in fixed_object["to"]
	end
	end

	describe "fix_summary/1" do
	test "returns fixed object" do
	assert Transmogrifier.fix_summary(%{"summary" => nil}) == %{"summary" => ""}
	assert Transmogrifier.fix_summary(%{"summary" => "ok"}) == %{"summary" => "ok"}
	assert Transmogrifier.fix_summary(%{}) == %{"summary" => ""}
	end
	end

	describe "fix_url/1" do
	test "fixes data for object when url is map" do
	object = %{
	"url" => %{
	"type" => "Link",
	"mimeType" => "video/mp4",
	"href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	}

	assert Transmogrifier.fix_url(object) == %{
	"url" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	}
	end

	test "returns non-modified object" do
	assert Transmogrifier.fix_url(%{"type" => "Text"}) == %{"type" => "Text"}
	end
	end

	describe "get_obj_helper/2" do
	test "returns nil when cannot normalize object" do
	assert capture_log(fn ->
	refute Transmogrifier.get_obj_helper("test-obj-id")
	end) =~ "Unsupported URI scheme"
	end

	test "returns {:ok, %Object{}} for success case" do
	assert {:ok, %Object{}} =
	Transmogrifier.get_obj_helper(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	)
	end
	end

	describe "fix_attachments/1" do
	test "puts dimensions into attachment url field" do
	object = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960,
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	expected = %{
	"attachment" => [
	%{
	"type" => "Document",
	"name" => "Hello world",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpeg",
	"href" => "https://media.example.tld/1.jpg",
	"width" => 880,
	"height" => 960
	}
	],
	"mediaType" => "image/jpeg",
	"blurhash" => "eTKL26+HDjcEIBVl;ds+K6t301W.t7nit7y1E,R:v}ai4nXSt7V@of"
	}
	]
	}

	assert Transmogrifier.fix_attachments(object) == expected
	end
	end

	describe "prepare_object/1" do
	test "it processes history" do
	original = %{
	"formerRepresentations" => %{
	"orderedItems" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)

	history_item = Enum.at(processed["formerRepresentations"]["orderedItems"], 0)

	refute Map.has_key?(history_item, "generator")

	assert [%{"name" => ":blobcat:"}] = history_item["tag"]
	end

	test "it works when there is no or bad history" do
	original = %{
	"formerRepresentations" => %{
	"items" => [
	%{
	"generator" => %{},
	"emoji" => %{"blobcat" => "http://localhost:4001/emoji/blobcat.png"}
	}
	]
	}
	}

	processed = Transmogrifier.prepare_object(original)
	assert processed["formerRepresentations"] == original["formerRepresentations"]
	end

	test "it uses contentMap to specify post language" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cześć", language: "pl"})
	object = Transmogrifier.prepare_object(activity.object.data)

	assert %{"contentMap" => %{"pl" => "Cześć"}} = object
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/account_view_test.exs b/test/pleroma/web/mastodon_api/views/account_view_test.exs
	index 5d24c0e9f..bd151cc61 100644
	--- a/test/pleroma/web/mastodon_api/views/account_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/account_view_test.exs
	@@ -1,848 +1,867 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
	use Pleroma.DataCase, async: false

	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView

	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "Represent a user account" do
	background_image = %{
	"url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
	}

	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	background: background_image,
	nickname: "shp@shitposter.club",
	name: ":karjalanpiirakka: shp",
	bio:
	"<script src=\"invalid-html\"></script><span>valid html</span>. a<br>b<br/>c<br >d<br />f '&<>\"",
	inserted_at: ~N[2017-08-15 15:47:06.597036],
	emoji: %{"karjalanpiirakka" => "/file.png"},
	raw_bio: "valid html. a\nb\nc\nd\nf '&<>\"",
	also_known_as: ["https://shitposter.zone/users/shp"],
	last_status_at: NaiveDateTime.utc_now()
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: "<span>valid html</span>. a<br/>b<br/>c<br/>d<br/>f '&<>"",
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [
	%{
	static_url: "/file.png",
	url: "/file.png",
	shortcode: "karjalanpiirakka",
	visible_in_picker: false
	}
	],
	fields: [],
	bot: false,
	source: %{
	note: "valid html. a\nb\nc\nd\nf '&<>\"",
	sensitive: false,
	pleroma: %{
	actor_type: "Person",
	discoverable: true
	},
	fields: []
	},
	fqn: "shp@shitposter.club",
	last_status_at: user.last_status_at \|> NaiveDateTime.to_date() \|> Date.to_iso8601(),
	pleroma: %{
	ap_id: user.ap_id,
	also_known_as: ["https://shitposter.zone/users/shp"],
	background_image: "https://example.com/images/asuka_hospital.png",
	favicon: nil,
	is_confirmed: true,
	tags: [],
	is_admin: false,
	is_moderator: false,
	privileges: [],
	is_suggested: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false,
	accepts_chat_messages: nil,
	avatar_description: "",
	header_description: ""
	}
	}

	assert expected == AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	+ test "encodes emoji urls in the emojis field" do
	+ user =
	+ insert(:user,
	+ name: ":brackets: :percent:",
	+ emoji: %{
	+ "brackets" => "/emoji/hana[pog].png",
	+ "percent" => "/emoji/hana%20pog.png"
	+ }
	+ )
	+
	+ %{emojis: emojis} =
	+ AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	+
	+ emoji_urls = Map.new(emojis, &{&1.shortcode, &1.url})
	+
	+ assert emoji_urls["brackets"] == "/emoji/hana%5Bpog%5D.png"
	+ assert emoji_urls["percent"] == "/emoji/hana%2520pog.png"
	+ end
	+
	describe "roles and privileges" do
	setup do
	clear_config([:instance, :moderator_privileges], [:cofe, :only_moderator])
	clear_config([:instance, :admin_privileges], [:cofe, :only_admin])

	%{
	user: insert(:user),
	moderator: insert(:user, is_moderator: true),
	admin: insert(:user, is_admin: true),
	moderator_admin: insert(:user, is_moderator: true, is_admin: true),
	user_no_show_roles: insert(:user, show_role: false),
	moderator_admin_no_show_roles:
	insert(:user, is_moderator: true, is_admin: true, show_role: false)
	}
	end

	test "shows roles and privileges when show_role: true", %{
	user: user,
	moderator: moderator,
	admin: admin,
	moderator_admin: moderator_admin,
	user_no_show_roles: user_no_show_roles,
	moderator_admin_no_show_roles: moderator_admin_no_show_roles
	} do
	assert %{pleroma: %{is_moderator: false, is_admin: false}} =
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})

	assert [] ==
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})[
	:pleroma
	][:privileges]
	\|> Enum.sort()

	assert %{pleroma: %{is_moderator: true, is_admin: false}} =
	AccountView.render("show.json", %{user: moderator, skip_visibility_check: true})

	assert [:cofe, :only_moderator] ==
	AccountView.render("show.json", %{user: moderator, skip_visibility_check: true})[
	:pleroma
	][:privileges]
	\|> Enum.sort()

	assert %{pleroma: %{is_moderator: false, is_admin: true}} =
	AccountView.render("show.json", %{user: admin, skip_visibility_check: true})

	assert [:cofe, :only_admin] ==
	AccountView.render("show.json", %{user: admin, skip_visibility_check: true})[
	:pleroma
	][:privileges]
	\|> Enum.sort()

	assert %{pleroma: %{is_moderator: true, is_admin: true}} =
	AccountView.render("show.json", %{
	user: moderator_admin,
	skip_visibility_check: true
	})

	assert [:cofe, :only_admin, :only_moderator] ==
	AccountView.render("show.json", %{
	user: moderator_admin,
	skip_visibility_check: true
	})[:pleroma][:privileges]
	\|> Enum.sort()

	refute match?(
	%{pleroma: %{is_moderator: _}},
	AccountView.render("show.json", %{
	user: user_no_show_roles,
	skip_visibility_check: true
	})
	)

	refute match?(
	%{pleroma: %{is_admin: _}},
	AccountView.render("show.json", %{
	user: user_no_show_roles,
	skip_visibility_check: true
	})
	)

	refute match?(
	%{pleroma: %{privileges: _}},
	AccountView.render("show.json", %{
	user: user_no_show_roles,
	skip_visibility_check: true
	})
	)

	refute match?(
	%{pleroma: %{is_moderator: _}},
	AccountView.render("show.json", %{
	user: moderator_admin_no_show_roles,
	skip_visibility_check: true
	})
	)

	refute match?(
	%{pleroma: %{is_admin: _}},
	AccountView.render("show.json", %{
	user: moderator_admin_no_show_roles,
	skip_visibility_check: true
	})
	)

	refute match?(
	%{pleroma: %{privileges: _}},
	AccountView.render("show.json", %{
	user: moderator_admin_no_show_roles,
	skip_visibility_check: true
	})
	)
	end

	test "shows roles and privileges when viewing own account, even when show_role: false", %{
	user_no_show_roles: user_no_show_roles,
	moderator_admin_no_show_roles: moderator_admin_no_show_roles
	} do
	assert %{pleroma: %{is_moderator: false, is_admin: false, privileges: []}} =
	AccountView.render("show.json", %{
	user: user_no_show_roles,
	skip_visibility_check: true,
	for: user_no_show_roles
	})

	assert %{
	pleroma: %{
	is_moderator: true,
	is_admin: true,
	privileges: privileges
	}
	} =
	AccountView.render("show.json", %{
	user: moderator_admin_no_show_roles,
	skip_visibility_check: true,
	for: moderator_admin_no_show_roles
	})

	assert [:cofe, :only_admin, :only_moderator] == privileges \|> Enum.sort()
	end
	end

	describe "favicon" do
	setup do
	[user: insert(:user)]
	end

	test "is parsed when :instance_favicons is enabled", %{user: user} do
	clear_config([:instances_favicons, :enabled], true)

	assert %{
	pleroma: %{
	favicon:
	"https://shitposter.club/plugins/Qvitter/img/gnusocial-favicons/favicon-16x16.png"
	}
	} = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	test "is nil when :instances_favicons is disabled", %{user: user} do
	assert %{pleroma: %{favicon: nil}} =
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end
	end

	test "Represent the user account for the account owner" do
	user = insert(:user)

	notification_settings = %{
	block_from_strangers: false,
	hide_notification_contents: false
	}

	privacy = user.default_scope

	assert %{
	pleroma: %{notification_settings: ^notification_settings, allow_following_move: true},
	source: %{privacy: ^privacy}
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	actor_type: "Service",
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{
	actor_type: "Service",
	discoverable: true
	},
	fields: []
	},
	fqn: "shp@shitposter.club",
	last_status_at: nil,
	pleroma: %{
	ap_id: user.ap_id,
	also_known_as: [],
	background_image: nil,
	favicon: nil,
	is_confirmed: true,
	tags: [],
	is_admin: false,
	is_moderator: false,
	privileges: [],
	is_suggested: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false,
	accepts_chat_messages: nil,
	avatar_description: "",
	header_description: ""
	}
	}

	assert expected == AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	test "Represent a Funkwhale channel" do
	{:ok, user} =
	User.get_or_fetch_by_ap_id(
	"https://channels.tests.funkwhale.audio/federation/actors/compositions"
	)

	assert represented =
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})

	assert represented.acct == "compositions@channels.tests.funkwhale.audio"
	assert represented.url == "https://channels.tests.funkwhale.audio/channels/compositions"
	end

	test "Represent a deactivated user for a privileged user" do
	clear_config([:instance, :moderator_privileges], [:users_manage_activation_state])

	admin = insert(:user, is_moderator: true)
	deactivated_user = insert(:user, is_active: false)
	represented = AccountView.render("show.json", %{user: deactivated_user, for: admin})
	assert represented[:pleroma][:deactivated] == true
	end

	test "Represent a smaller mention" do
	user = insert(:user)

	expected = %{
	id: to_string(user.id),
	acct: user.nickname,
	username: user.nickname,
	url: user.ap_id
	}

	assert expected == AccountView.render("mention.json", %{user: user})
	end

	test "demands :for or :skip_visibility_check option for account rendering" do
	clear_config([:restrict_unauthenticated, :profiles, :local], false)

	user = insert(:user)
	user_id = user.id

	assert %{id: ^user_id} = AccountView.render("show.json", %{user: user, for: nil})
	assert %{id: ^user_id} = AccountView.render("show.json", %{user: user, for: user})

	assert %{id: ^user_id} =
	AccountView.render("show.json", %{user: user, skip_visibility_check: true})

	assert_raise RuntimeError, ~r/:skip_visibility_check or :for option is required/, fn ->
	AccountView.render("show.json", %{user: user})
	end
	end

	describe "relationship" do
	defp test_relationship_rendering(user, other_user, expected_result) do
	opts = %{user: user, target: other_user, relationships: nil}
	assert expected_result == AccountView.render("relationship.json", opts)

	relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
	opts = Map.put(opts, :relationships, relationships_opt)
	assert expected_result == AccountView.render("relationship.json", opts)

	assert [expected_result] ==
	AccountView.render("relationships.json", %{user: user, targets: [other_user]})
	end

	@blank_response %{
	following: false,
	followed_by: false,
	blocking: false,
	blocked_by: false,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	notifying: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false,
	note: ""
	}

	test "represent a relationship for the following and followed user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user, other_user} = User.follow(user, other_user)
	{:ok, other_user, user} = User.follow(other_user, user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationships} = User.mute(user, other_user, %{notifications: true})
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(other_user, user)

	expected =
	Map.merge(
	@blank_response,
	%{
	following: true,
	followed_by: true,
	muting: true,
	muting_notifications: true,
	subscribing: true,
	notifying: true,
	showing_reblogs: false,
	id: to_string(other_user.id)
	}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "relationship does not indicate following if a FollowingRelationship is missing" do
	user = insert(:user)
	other_user = insert(:user, local: false)

	# Create a follow relationship with the real Follow Activity and Accept it
	assert {:ok, _, _, _} = CommonAPI.follow(other_user, user)
	assert {:ok, _} = CommonAPI.accept_follow_request(user, other_user)

	assert %{data: %{"state" => "accept"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(user, other_user)

	# Fetch the relationship and forcibly delete it to simulate
	# a Follow Accept that did not complete processing
	%{following_relationships: [relationship]} =
	Pleroma.UserRelationship.view_relationships_option(user, [other_user])

	assert {:ok, _} = Pleroma.Repo.delete(relationship)

	assert %{following_relationships: [], user_relationships: []} ==
	Pleroma.UserRelationship.view_relationships_option(user, [other_user])

	expected =
	Map.merge(
	@blank_response,
	%{
	following: false,
	followed_by: false,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	notifying: false,
	showing_reblogs: true,
	id: to_string(other_user.id)
	}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the blocking and blocked user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user, other_user} = User.follow(user, other_user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationship} = User.block(user, other_user)
	{:ok, _user_relationship} = User.block(other_user, user)

	expected =
	Map.merge(
	@blank_response,
	%{following: false, blocking: true, blocked_by: true, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the user blocking a domain" do
	user = insert(:user)
	other_user = insert(:user, ap_id: "https://bad.site/users/other_user")

	{:ok, user} = User.block_domain(user, "bad.site")

	expected =
	Map.merge(
	@blank_response,
	%{domain_blocking: true, blocking: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the user with a pending follow request" do
	user = insert(:user)
	other_user = insert(:user, is_locked: true)

	{:ok, other_user, user, _} = CommonAPI.follow(other_user, user)
	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	expected =
	Map.merge(
	@blank_response,
	%{requested: true, following: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end
	end

	test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
	user = insert(:user, pleroma_settings_store: %{fe: "test"})

	result =
	AccountView.render("show.json", %{user: user, for: user, with_pleroma_settings: true})

	assert result.pleroma.settings_store == %{:fe => "test"}

	result = AccountView.render("show.json", %{user: user, for: nil, with_pleroma_settings: true})
	assert result.pleroma[:settings_store] == nil

	result = AccountView.render("show.json", %{user: user, for: user})
	assert result.pleroma[:settings_store] == nil
	end

	test "doesn't sanitize display names" do
	user = insert(:user, name: "<marquee> username </marquee>")
	result = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	assert result.display_name == "<marquee> username </marquee>"
	end

	test "never display nil user follow counts" do
	user = insert(:user, following_count: 0, follower_count: 0)
	result = AccountView.render("show.json", %{user: user, skip_visibility_check: true})

	assert result.following_count == 0
	assert result.followers_count == 0
	end

	describe "hiding follows/following" do
	test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do
	user =
	insert(:user, %{
	hide_followers: true,
	hide_followers_count: true,
	hide_follows: true,
	hide_follows_count: true
	})

	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(other_user, user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(user, other_user)

	assert %{
	followers_count: 0,
	following_count: 0,
	pleroma: %{hide_follows_count: true, hide_followers_count: true}
	} = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	test "shows when follows/followers are hidden" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	assert %{
	followers_count: 1,
	following_count: 1,
	pleroma: %{hide_follows: true, hide_followers: true}
	} = AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	end

	test "shows actual follower/following count to the account owner" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert User.following?(user, other_user)
	assert Pleroma.FollowingRelationship.follower_count(other_user) == 1
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	assert %{
	followers_count: 1,
	following_count: 1
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows unread_conversation_count only to the account owner" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(other_user, %{
	status: "Hey @#{user.nickname}.",
	visibility: "direct"
	})

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render("show.json", %{user: user, for: other_user})[:pleroma][
	:unread_conversation_count
	] == nil

	assert AccountView.render("show.json", %{user: user, for: user})[:pleroma][
	:unread_conversation_count
	] == 1
	end

	test "shows unread_count only to the account owner" do
	user = insert(:user)
	insert_list(7, :notification, user: user, activity: insert(:note_activity))
	other_user = insert(:user)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render(
	"show.json",
	%{user: user, for: other_user}
	)[:pleroma][:unread_notifications_count] == nil

	assert AccountView.render(
	"show.json",
	%{user: user, for: user}
	)[:pleroma][:unread_notifications_count] == 7
	end

	test "shows email only to the account owner" do
	user = insert(:user)
	other_user = insert(:user)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render(
	"show.json",
	%{user: user, for: other_user}
	)[:pleroma][:email] == nil

	assert AccountView.render(
	"show.json",
	%{user: user, for: user}
	)[:pleroma][:email] == user.email
	end
	end

	describe "hiding birthday" do
	test "doesn't show birthday if hidden" do
	user =
	insert(:user, %{
	birthday: "2001-02-12",
	show_birthday: false
	})

	other_user = insert(:user)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render(
	"show.json",
	%{user: user, for: other_user}
	)[:birthday] == nil
	end

	test "shows hidden birthday to the account owner" do
	user =
	insert(:user, %{
	birthday: "2001-02-12",
	show_birthday: false
	})

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render(
	"show.json",
	%{user: user, for: user}
	)[:birthday] == nil
	end
	end

	describe "follow requests counter" do
	test "shows zero when no follow requests are pending" do
	user = insert(:user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(user, other_user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when follow requests are pending" do
	user = insert(:user, is_locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when accepting a follow request" do
	user = insert(:user, is_locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.accept_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when rejecting a follow request" do
	user = insert(:user, is_locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.reject_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when historical unapproved requests are present" do
	user = insert(:user, is_locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	{:ok, user} = User.update_and_set_cache(user, %{is_locked: false})

	assert %{locked: false, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end
	end

	test "uses mediaproxy urls when it's enabled (regardless of media preview proxy state)" do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled])

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://evil.website/avatar.png"}]},
	banner: %{"url" => [%{"href" => "https://evil.website/banner.png"}]},
	emoji: %{"joker_smile" => "https://evil.website/society.png"}
	)

	Enum.each([true, false], fn media_preview_enabled ->
	clear_config([:media_preview_proxy, :enabled], media_preview_enabled)

	AccountView.render("show.json", %{user: user, skip_visibility_check: true})
	\|> Enum.all?(fn
	{key, url} when key in [:avatar, :avatar_static, :header, :header_static] ->
	String.starts_with?(url, Pleroma.Web.Endpoint.url())

	{:emojis, emojis} ->
	Enum.all?(emojis, fn %{url: url, static_url: static_url} ->
	String.starts_with?(url, Pleroma.Web.Endpoint.url()) &&
	String.starts_with?(static_url, Pleroma.Web.Endpoint.url())
	end)

	_ ->
	true
	end)
	\|> assert()
	end)
	end

	test "renders mute expiration date" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _user_relationships} =
	User.mute(user, other_user, %{notifications: true, duration: 24 * 60 * 60})

	%{
	mute_expires_at: mute_expires_at
	} = AccountView.render("show.json", %{user: other_user, for: user, mutes: true})

	assert DateTime.diff(
	mute_expires_at,
	DateTime.utc_now() \|> DateTime.add(24 * 60 * 60)
	) in -3..3
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/notification_view_test.exs b/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	index ce5ddd0fc..c8287bb79 100644
	--- a/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	@@ -1,374 +1,374 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
	use Pleroma.DataCase, async: false

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.AdminAPI.Report
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView
	import Pleroma.Factory

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	defp test_notifications_rendering(notifications, user, expected_result) do
	result = NotificationView.render("index.json", %{notifications: notifications, for: user})

	assert expected_result == result

	result =
	NotificationView.render("index.json", %{
	notifications: notifications,
	for: user,
	relationships: nil
	})

	assert expected_result == result
	end

	test "ChatMessage notification" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, activity} = CommonAPI.post_chat_message(user, recipient, "what's up my dude")

	{:ok, [notification]} = Notification.create_notifications(activity)

	object = Object.normalize(activity, fetch: false)
	chat = Chat.get(recipient.id, user.ap_id)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:chat_mention",
	account: AccountView.render("show.json", %{user: user, for: recipient}),
	chat_message: MessageReferenceView.render("show.json", %{chat_message_reference: cm_ref}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], recipient, [expected])
	end

	test "Mention notification" do
	user = insert(:user)
	mentioned_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{mentioned_user.nickname}"})
	{:ok, [notification]} = Notification.create_notifications(activity)
	user = User.get_cached_by_id(user.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "mention",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: mentioned_user
	}),
	status: StatusView.render("show.json", %{activity: activity, for: mentioned_user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], mentioned_user, [expected])
	end

	test "Favourite notification" do
	user = insert(:user)
	another_user = insert(:user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, favorite_activity} = CommonAPI.favorite(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(favorite_activity)
	create_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "favourite",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: create_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Reblog notification" do
	user = insert(:user)
	another_user = insert(:user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(reblog_activity)
	reblog_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "reblog",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: reblog_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Follow notification" do
	follower = insert(:user)
	followed = insert(:user)
	{:ok, followed, follower, _activity} = CommonAPI.follow(followed, follower)
	notification = Notification \|> Repo.one() \|> Repo.preload(:activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "follow",
	account: AccountView.render("show.json", %{user: follower, for: followed}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], followed, [expected])

	User.perform(:delete, follower)
	refute Repo.one(Notification)
	end

	test "Move notification" do
	old_user = insert(:user)
	new_user = insert(:user, also_known_as: [old_user.ap_id])
	follower = insert(:user)

	User.follow(follower, old_user)
	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	Pleroma.Tests.ObanHelpers.perform_all()

	old_user = refresh_record(old_user)
	new_user = refresh_record(new_user)

	[notification] = Notification.for_user(follower)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "move",
	account: AccountView.render("show.json", %{user: old_user, for: follower}),
	target: AccountView.render("show.json", %{user: new_user, for: follower}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], follower, [expected])
	end

	test "EmojiReact notification" do
	user = insert(:user)
	other_user = insert(:user)

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

	activity = Repo.get(Activity, activity.id)

	[notification] = Notification.for_user(user)

	assert notification

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:emoji_reaction",
	emoji: "☕",
	account: AccountView.render("show.json", %{user: other_user, for: user}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	emoji_url: nil
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "EmojiReact custom emoji notification" do
	user = insert(:user)
	other_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [
	["👍", [user.ap_id], nil],
	- ["dinosaur", [user.ap_id], "http://localhost:4001/emoji/dino walking.gif"]
	+ ["dinosaur", [user.ap_id], "http://localhost:4001/emoji/dino%20walking.gif"]
	]
	}
	)

	activity = insert(:note_activity, note: note, user: user)

	{:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "dinosaur")

	activity = Repo.get(Activity, activity.id)

	[notification] = Notification.for_user(user)

	assert notification

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:emoji_reaction",
	emoji: ":dinosaur:",
	account: AccountView.render("show.json", %{user: other_user, for: user}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	- emoji_url: "http://localhost:4001/emoji/dino walking.gif"
	+ emoji_url: "http://localhost:4001/emoji/dino%20walking.gif"
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Poll notification" do
	user = insert(:user)
	activity = insert(:question_activity, user: user)
	{:ok, [notification]} = Notification.create_poll_notifications(activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "poll",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: user
	}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Report notification" do
	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])

	reporting_user = insert(:user)
	reported_user = insert(:user)
	moderator_user = insert(:user, is_moderator: true)

	{:ok, activity} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, [notification]} = Notification.create_notifications(activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:report",
	account: AccountView.render("show.json", %{user: reporting_user, for: moderator_user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	report: ReportView.render("show.json", Report.extract_report_info(activity))
	}

	test_notifications_rendering([notification], moderator_user, [expected])
	end

	test "Edit notification" do
	user = insert(:user)
	repeat_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "mew"})
	{:ok, _} = CommonAPI.repeat(activity.id, repeat_user)
	{:ok, update} = CommonAPI.update(activity, user, %{status: "mew mew"})

	user = Pleroma.User.get_by_ap_id(user.ap_id)
	activity = Pleroma.Activity.normalize(activity)
	update = Pleroma.Activity.normalize(update)

	{:ok, [notification]} = Notification.create_notifications(update)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "update",
	account: AccountView.render("show.json", %{user: user, for: repeat_user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	status: StatusView.render("show.json", %{activity: activity, for: repeat_user})
	}

	test_notifications_rendering([notification], repeat_user, [expected])
	end

	test "muted notification" do
	user = insert(:user)
	another_user = insert(:user)

	{:ok, _} = Pleroma.UserRelationship.create_mute(user, another_user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, favorite_activity} = CommonAPI.favorite(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(favorite_activity)
	create_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: true, is_muted: true},
	type: "favourite",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: create_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Subscribed status notification" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hi"})
	{:ok, [notification]} = Notification.create_notifications(activity)

	user = User.get_cached_by_id(user.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "status",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: subscriber
	}),
	status: StatusView.render("show.json", %{activity: activity, for: subscriber}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], subscriber, [expected])
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/status_view_test.exs b/test/pleroma/web/mastodon_api/views/status_view_test.exs
	index d7908886b..73cab817b 100644
	--- a/test/pleroma/web/mastodon_api/views/status_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/status_view_test.exs
	@@ -1,1012 +1,1012 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Conversation.Participation
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.RichMedia.Card

	require Bitwise

	import Mox
	import OpenApiSpex.TestAssertions
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "has an emoji reaction list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "dae cofe??"})

	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, "☕")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user, ":dinosaur:")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, third_user, "🍵")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, other_user, ":dinosaur:")

	activity = Repo.get(Activity, activity.id)
	status = StatusView.render("show.json", activity: activity)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: false, url: nil, account_ids: [other_user.id, user.id]},
	%{
	count: 2,
	me: false,
	name: "dinosaur",
	- url: "http://localhost:4001/emoji/dino walking.gif",
	+ url: "http://localhost:4001/emoji/dino%20walking.gif",
	account_ids: [other_user.id, user.id]
	},
	%{name: "🍵", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 2, me: true, url: nil, account_ids: [other_user.id, user.id]},
	%{
	count: 2,
	me: true,
	name: "dinosaur",
	- url: "http://localhost:4001/emoji/dino walking.gif",
	+ url: "http://localhost:4001/emoji/dino%20walking.gif",
	account_ids: [other_user.id, user.id]
	},
	%{name: "🍵", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]
	end

	test "works with legacy-formatted reactions" do
	user = insert(:user)
	other_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [["😿", [other_user.ap_id]]]
	}
	)

	activity = insert(:note_activity, user: user, note: note)

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "😿", count: 1, me: false, url: nil, account_ids: [other_user.id]}
	]
	end

	test "works correctly with badly formatted emojis" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "yo"})

	activity
	\|> Object.normalize(fetch: false)
	\|> Object.update_data(%{"reactions" => %{"☕" => [user.ap_id], "x" => 1}})

	activity = Activity.get_by_id(activity.id)
	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: true, url: nil, account_ids: [user.id]}
	]
	end

	test "doesn't show reactions from muted and blocked users" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	{:ok, _} = User.mute(user, other_user)
	{:ok, _} = User.block(other_user, third_user)

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

	activity = Repo.get(Activity, activity.id)
	status = StatusView.render("show.json", activity: activity)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: false, url: nil, account_ids: [other_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == []

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

	status = StatusView.render("show.json", activity: activity)

	assert status[:pleroma][:emoji_reactions] == [
	%{
	name: "☕",
	count: 2,
	me: false,
	url: nil,
	account_ids: [third_user.id, other_user.id]
	}
	]

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: false, url: nil, account_ids: [third_user.id]}
	]

	status = StatusView.render("show.json", activity: activity, for: other_user)

	assert status[:pleroma][:emoji_reactions] == [
	%{name: "☕", count: 1, me: true, url: nil, account_ids: [other_user.id]}
	]
	end

	test "loads and returns the direct conversation id when given the `with_direct_conversation_id` option" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
	[participation] = Participation.for_user(user)

	status =
	StatusView.render("show.json",
	activity: activity,
	with_direct_conversation_id: true,
	for: user
	)

	assert status[:pleroma][:direct_conversation_id] == participation.id

	status = StatusView.render("show.json", activity: activity, for: user)
	assert status[:pleroma][:direct_conversation_id] == nil
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "returns the direct conversation id when given the `direct_conversation_id` option" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})
	[participation] = Participation.for_user(user)

	status =
	StatusView.render("show.json",
	activity: activity,
	direct_conversation_id: participation.id,
	for: user
	)

	assert status[:pleroma][:direct_conversation_id] == participation.id
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})

	Repo.delete(user)
	User.invalidate_cache(user)

	finger_url =
	"https://localhost/.well-known/webfinger?resource=acct:#{user.nickname}@localhost"

	Tesla.Mock.mock_global(fn
	%{method: :get, url: "http://localhost/.well-known/host-meta"} ->
	%Tesla.Env{status: 404, body: ""}

	%{method: :get, url: "https://localhost/.well-known/host-meta"} ->
	%Tesla.Env{status: 404, body: ""}

	%{
	method: :get,
	url: ^finger_url
	} ->
	%Tesla.Env{status: 404, body: ""}
	end)

	%{account: ms_user} = StatusView.render("show.json", activity: activity)

	assert ms_user.acct == "erroruser@example.com"
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Hey @shp!", visibility: "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	User.invalidate_cache(user)

	result = StatusView.render("show.json", activity: activity)

	assert result[:account][:id] == to_string(user.id)
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a note with null content" do
	note = insert(:note_activity)
	note_object = Object.normalize(note, fetch: false)

	data =
	note_object.data
	\|> Map.put("content", nil)

	Object.change(note_object, %{data: data})
	\|> Object.update_and_set_cache()

	User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("show.json", %{activity: note})

	assert status.content == ""
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a note activity" do
	note = insert(:note_activity)
	object_data = Object.normalize(note, fetch: false).data
	user = User.get_cached_by_ap_id(note.data["actor"])

	convo_id = :erlang.crc32(object_data["context"]) \|> Bitwise.band(Bitwise.bnot(0x8000_0000))

	status = StatusView.render("show.json", %{activity: note})

	created_at =
	(object_data["published"] \|\| "")
	\|> String.replace(~r/\.\d+Z/, ".000Z")

	expected = %{
	id: to_string(note.id),
	uri: object_data["id"],
	url: Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, note),
	account: AccountView.render("show.json", %{user: user, skip_visibility_check: true}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	card: nil,
	reblog: nil,
	content: HTML.filter_tags(object_data["content"]),
	text: nil,
	created_at: created_at,
	edited_at: nil,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	bookmarked: false,
	favourited: false,
	muted: false,
	pinned: false,
	sensitive: false,
	poll: nil,
	spoiler_text: HTML.filter_tags(object_data["summary"]),
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [
	%{
	name: "#{hd(object_data["tag"])}",
	url: "http://localhost:4001/tag/#{hd(object_data["tag"])}"
	}
	],
	application: nil,
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	],
	pleroma: %{
	local: true,
	conversation_id: convo_id,
	context: object_data["context"],
	in_reply_to_account_acct: nil,
	quote: nil,
	quote_id: nil,
	quote_url: nil,
	quote_visible: false,
	content: %{"text/plain" => HTML.strip_tags(object_data["content"])},
	spoiler_text: %{"text/plain" => HTML.strip_tags(object_data["summary"])},
	expires_at: nil,
	direct_conversation_id: nil,
	thread_muted: false,
	emoji_reactions: [],
	parent_visible: false,
	pinned_at: nil,
	quotes_count: 0,
	bookmark_folder: nil,
	list_id: nil
	},
	quotes_count: 0
	}

	assert status == expected
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "tells if the message is muted for some reason" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, other_user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "test"})

	relationships_opt = UserRelationship.view_relationships_option(user, [other_user])

	opts = %{activity: activity}
	status = StatusView.render("show.json", opts)
	assert status.muted == false
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())

	status = StatusView.render("show.json", Map.put(opts, :relationships, relationships_opt))
	assert status.muted == false

	for_opts = %{activity: activity, for: user}
	status = StatusView.render("show.json", for_opts)
	assert status.muted == true

	status = StatusView.render("show.json", Map.put(for_opts, :relationships, relationships_opt))
	assert status.muted == true
	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "tells if the message is thread muted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, other_user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "test"})
	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.pleroma.thread_muted == false

	{:ok, activity} = CommonAPI.add_mute(activity, user)

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.pleroma.thread_muted == true
	end

	test "tells if the status is bookmarked" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Cute girls doing cute things"})
	status = StatusView.render("show.json", %{activity: activity})

	assert status.bookmarked == false

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.bookmarked == false

	{:ok, _bookmark} = Bookmark.create(user.id, activity.id)

	activity = Activity.get_by_id_with_object(activity.id)

	status = StatusView.render("show.json", %{activity: activity, for: user})

	assert status.bookmarked == true
	end

	test "a reply" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "he", in_reply_to_status_id: note.id})

	status = StatusView.render("show.json", %{activity: activity})

	assert status.in_reply_to_id == to_string(note.id)

	[status] = StatusView.render("index.json", %{activities: [activity], as: :activity})

	assert status.in_reply_to_id == to_string(note.id)
	end

	test "a quote post" do
	post = insert(:note_activity)
	user = insert(:user)

	{:ok, quote_post} = CommonAPI.post(user, %{status: "he", quoted_status_id: post.id})

	{:ok, quoted_quote_post} =
	CommonAPI.post(user, %{status: "yo", quoted_status_id: quote_post.id})

	status = StatusView.render("show.json", %{activity: quoted_quote_post})

	assert status.pleroma.quote.id == to_string(quote_post.id)
	assert status.pleroma.quote_id == to_string(quote_post.id)
	assert status.pleroma.quote_url == Object.normalize(quote_post).data["id"]
	assert status.pleroma.quote_visible

	# Quotes don't go more than one level deep
	refute status.pleroma.quote.pleroma.quote
	assert status.pleroma.quote.pleroma.quote_id == to_string(post.id)
	assert status.pleroma.quote.pleroma.quote_url == Object.normalize(post).data["id"]
	assert status.pleroma.quote.pleroma.quote_visible

	# In an index
	[status] = StatusView.render("index.json", %{activities: [quoted_quote_post], as: :activity})

	assert status.pleroma.quote.id == to_string(quote_post.id)
	end

	test "quoted private post" do
	user = insert(:user)

	# Insert a private post
	private = insert(:followers_only_note_activity, user: user)
	private_object = Object.normalize(private)

	# Create a public post quoting the private post
	quote_private =
	insert(:note_activity,
	note: insert(:note, data: %{"quoteUrl" => private_object.data["id"]})
	)

	status = StatusView.render("show.json", %{activity: quote_private})

	# The quote isn't rendered
	refute status.pleroma.quote
	assert status.pleroma.quote_url == private_object.data["id"]
	refute status.pleroma.quote_visible

	# After following the user, the quote is rendered
	follower = insert(:user)
	CommonAPI.follow(user, follower)

	status = StatusView.render("show.json", %{activity: quote_private, for: follower})
	assert status.pleroma.quote.id == to_string(private.id)
	assert status.pleroma.quote_visible
	end

	test "quoted direct message" do
	# Insert a direct message
	direct = insert(:direct_note_activity)
	direct_object = Object.normalize(direct)

	# Create a public post quoting the direct message
	quote_direct =
	insert(:note_activity, note: insert(:note, data: %{"quoteUrl" => direct_object.data["id"]}))

	status = StatusView.render("show.json", %{activity: quote_direct})

	# The quote isn't rendered
	refute status.pleroma.quote
	assert status.pleroma.quote_url == direct_object.data["id"]
	refute status.pleroma.quote_visible
	end

	test "repost of quote post" do
	post = insert(:note_activity)
	user = insert(:user)

	{:ok, quote_post} = CommonAPI.post(user, %{status: "he", quoted_status_id: post.id})
	{:ok, repost} = CommonAPI.repeat(quote_post.id, user)

	[status] = StatusView.render("index.json", %{activities: [repost], as: :activity})

	assert status.reblog.pleroma.quote.id == to_string(post.id)
	end

	test "contains mentions" do
	user = insert(:user)
	mentioned = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hi @#{mentioned.nickname}"})

	status = StatusView.render("show.json", %{activity: activity})

	assert status.mentions ==
	Enum.map([mentioned], fn u -> AccountView.render("mention.json", %{user: u}) end)

	assert_schema(status, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "create mentions from the 'to' field" do
	%User{ap_id: recipient_ap_id} = insert(:user)
	cc = insert_pair(:user) \|> Enum.map(& &1.ap_id)

	object =
	insert(:note, %{
	data: %{
	"to" => [recipient_ap_id],
	"cc" => cc
	}
	})

	activity =
	insert(:note_activity, %{
	note: object,
	recipients: [recipient_ap_id \| cc]
	})

	assert length(activity.recipients) == 3

	%{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})

	assert length(mentions) == 1
	assert mention.url == recipient_ap_id
	end

	test "create mentions from the 'tag' field" do
	recipient = insert(:user)
	cc = insert_pair(:user) \|> Enum.map(& &1.ap_id)

	object =
	insert(:note, %{
	data: %{
	"cc" => cc,
	"tag" => [
	%{
	"href" => recipient.ap_id,
	"name" => recipient.nickname,
	"type" => "Mention"
	},
	%{
	"href" => "https://example.com/search?tag=test",
	"name" => "#test",
	"type" => "Hashtag"
	}
	]
	}
	})

	activity =
	insert(:note_activity, %{
	note: object,
	recipients: [recipient.ap_id \| cc]
	})

	assert length(activity.recipients) == 3

	%{mentions: [mention] = mentions} = StatusView.render("show.json", %{activity: activity})

	assert length(mentions) == 1
	assert mention.url == recipient.ap_id
	end

	describe "attachments" do
	test "Complete Mastodon style" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl",
	"width" => 200,
	"height" => 100
	}
	],
	"blurhash" => "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM\|9GV=WHRn",
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil,
	pleroma: %{mime_type: "image/png"},
	meta: %{original: %{width: 200, height: 100, aspect: 2}},
	blurhash: "UJJ8X[xYW,%Jtq%NNFbXB5j]IVM\|9GV=WHRn"
	}

	api_spec = Pleroma.Web.ApiSpec.spec()

	assert expected == StatusView.render("attachment.json", %{attachment: object})
	assert_schema(expected, "Attachment", api_spec)

	# If theres a "id", use that instead of the generated one
	object = Map.put(object, "id", 2)
	result = StatusView.render("attachment.json", %{attachment: object})

	assert %{id: "2"} = result
	assert_schema(result, "Attachment", api_spec)
	end

	test "Honkerific" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"name" => "fool.jpeg",
	"summary" => "they have played us for absolute fools."
	}

	expected = %{
	blurhash: nil,
	description: "they have played us for absolute fools.",
	id: "1638338801",
	pleroma: %{mime_type: "image/png", name: "fool.jpeg"},
	preview_url: "someurl",
	remote_url: "someurl",
	text_url: "someurl",
	type: "image",
	url: "someurl"
	}

	api_spec = Pleroma.Web.ApiSpec.spec()

	assert expected == StatusView.render("attachment.json", %{attachment: object})
	assert_schema(expected, "Attachment", api_spec)
	end
	end

	test "put the url advertised in the Activity in to the url attribute" do
	id = "https://wedistribute.org/wp-json/pterotype/v1/object/85810"
	[activity] = Activity.search(nil, id)

	status = StatusView.render("show.json", %{activity: activity})

	assert status.uri == id
	assert status.url == "https://wedistribute.org/2019/07/mastodon-drops-ostatus/"
	end

	test "a reblog" do
	user = insert(:user)
	activity = insert(:note_activity)

	{:ok, reblog} = CommonAPI.repeat(activity.id, user)

	represented = StatusView.render("show.json", %{for: user, activity: reblog})

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "a peertube video" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	assert_schema(represented, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "funkwhale audio" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://channels.tests.funkwhale.audio/federation/music/uploads/42342395-0208-4fee-a38d-259a6dae0871"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	end

	test "a Mobilizon event" do
	user = insert(:user)

	{:ok, object} =
	Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("show.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)

	assert represented[:url] ==
	"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39"

	assert represented[:content] ==
	"<p><a href=\"https://mobilizon.org/events/252d5816-00a3-4a89-a66f-15bf65c33e39\">Mobilizon Launching Party</a></p><p>Mobilizon is now federated! 🎉</p><p></p><p>You can view this event from other instances if they are subscribed to mobilizon.org, and soon directly from Mastodon and Pleroma. It is possible that you may see some comments from other instances, including Mastodon ones, just below.</p><p></p><p>With a Mobilizon account on an instance, you may <strong>participate</strong> at events from other instances and <strong>add comments</strong> on events.</p><p></p><p>Of course, it's still <u>a work in progress</u>: if reports made from an instance on events and comments can be federated, you can't block people right now, and moderators actions are rather limited, but this <strong>will definitely get fixed over time</strong> until first stable version next year.</p><p></p><p>Anyway, if you want to come up with some feedback, head over to our forum or - if you feel you have technical skills and are familiar with it - on our Gitlab repository.</p><p></p><p>Also, to people that want to set Mobilizon themselves even though we really don't advise to do that for now, we have a little documentation but it's quite the early days and you'll probably need some help. No worries, you can chat with us on our Forum or though our Matrix channel.</p><p></p><p>Check our website for more informations and follow us on Twitter or Mastodon.</p>"
	end

	describe "build_tags/1" do
	test "it returns a a dictionary tags" do
	object_tags = [
	"fediverse",
	"mastodon",
	"nextcloud",
	%{
	"href" => "https://kawen.space/users/lain",
	"name" => "@lain@kawen.space",
	"type" => "Mention"
	}
	]

	assert StatusView.build_tags(object_tags) == [
	%{name: "fediverse", url: "http://localhost:4001/tag/fediverse"},
	%{name: "mastodon", url: "http://localhost:4001/tag/mastodon"},
	%{name: "nextcloud", url: "http://localhost:4001/tag/nextcloud"}
	]
	end
	end

	describe "rich media cards" do
	test "a rich media card without a site name renders correctly" do
	page_url = "https://example.com"

	{:ok, card} =
	Card.create(page_url, %{image: page_url <> "/example.jpg", title: "Example website"})

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without a site name or image renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without an image renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card without descriptions returns the fields with empty strings" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(
	%{description: "", image_description: ""},
	StatusView.render("card.json", card)
	)
	end

	test "a rich media card with all relevant data renders correctly" do
	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website",
	"image" => page_url <> "/example.jpg",
	"description" => "Example description"
	}

	{:ok, card} = Card.create(page_url, fields)

	assert match?(%{provider_name: "example.com"}, StatusView.render("card.json", card))
	end

	test "a rich media card has all media proxied" do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled])

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	page_url = "https://example.com"

	fields = %{
	"url" => page_url,
	"site_name" => "Example site name",
	"title" => "Example website",
	"image" => page_url <> "/example.jpg",
	"audio" => page_url <> "/example.ogg",
	"video" => page_url <> "/example.mp4",
	"description" => "Example description"
	}

	{:ok, card} = Card.create(page_url, fields)

	%{
	provider_name: "example.com",
	image: image,
	pleroma: %{opengraph: og}
	} = StatusView.render("card.json", card)

	assert String.match?(image, ~r/\/proxy\//)
	assert String.match?(og["image"], ~r/\/proxy\//)
	assert String.match?(og["audio"], ~r/\/proxy\//)
	assert String.match?(og["video"], ~r/\/proxy\//)
	end
	end

	test "does not embed a relationship in the account" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "drink more water"
	})

	result = StatusView.render("show.json", %{activity: activity, for: other_user})

	assert result[:account][:pleroma][:relationship] == %{}
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "does not embed a relationship in the account in reposts" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "˙˙ɐʎns"
	})

	{:ok, activity} = CommonAPI.repeat(activity.id, other_user)

	result = StatusView.render("show.json", %{activity: activity, for: user})

	assert result[:account][:pleroma][:relationship] == %{}
	assert result[:reblog][:account][:pleroma][:relationship] == %{}
	assert_schema(result, "Status", Pleroma.Web.ApiSpec.spec())
	end

	test "visibility/list" do
	user = insert(:user)

	{:ok, list} = Pleroma.List.create("foo", user)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	status = StatusView.render("show.json", activity: activity)

	assert status.visibility == "list"
	assert status.pleroma.list_id == nil

	status = StatusView.render("show.json", activity: activity, for: user)

	assert status.pleroma.list_id == list.id
	end

	test "has a field for parent visibility" do
	user = insert(:user)
	poster = insert(:user)

	{:ok, invisible} = CommonAPI.post(poster, %{status: "hey", visibility: "private"})

	{:ok, visible} =
	CommonAPI.post(poster, %{status: "hey", visibility: "private", in_reply_to_id: invisible.id})

	status = StatusView.render("show.json", activity: visible, for: user)
	refute status.pleroma.parent_visible

	status = StatusView.render("show.json", activity: visible, for: poster)
	assert status.pleroma.parent_visible
	end

	test "it shows edited_at" do
	poster = insert(:user)

	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	status = StatusView.render("show.json", activity: post)
	refute status.edited_at

	{:ok, _} = CommonAPI.update(post, poster, %{status: "mew mew"})
	edited = Pleroma.Activity.normalize(post)

	status = StatusView.render("show.json", activity: edited)
	assert status.edited_at
	end

	test "it shows post language" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "Szczęść Boże", language: "pl"})

	status = StatusView.render("show.json", activity: post)

	assert status.language == "pl"
	end

	test "doesn't show post language if it's 'und'" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "sdifjogijodfg", language: "und"})

	status = StatusView.render("show.json", activity: post)

	assert status.language == nil
	end

	test "with a source object" do
	note =
	insert(:note,
	data: %{"source" => %{"content" => "object source", "mediaType" => "text/markdown"}}
	)

	activity = insert(:note_activity, note: note)

	status = StatusView.render("show.json", activity: activity, with_source: true)
	assert status.text == "object source"
	end

	describe "source.json" do
	test "with a source object, renders both source and content type" do
	note =
	insert(:note,
	data: %{"source" => %{"content" => "object source", "mediaType" => "text/markdown"}}
	)

	activity = insert(:note_activity, note: note)

	status = StatusView.render("source.json", activity: activity)
	assert status.text == "object source"
	assert status.content_type == "text/markdown"
	end

	test "with a source string, renders source and put text/plain as the content type" do
	note = insert(:note, data: %{"source" => "string source"})
	activity = insert(:note_activity, note: note)

	status = StatusView.render("source.json", activity: activity)
	assert status.text == "string source"
	assert status.content_type == "text/plain"
	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 79b805aca..8fcdb233b 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,480 +1,480 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	defp prepare_reacted_post(visibility \\ "private") do
	unrelated_user = insert(:user, local: true)
	poster = insert(:user, local: true)
	follower = insert(:user, local: true)
	{:ok, _, _, %{data: %{"state" => "accept"}}} = CommonAPI.follow(poster, follower)

	{:ok, post_activity} = CommonAPI.post(poster, %{status: "miaow!", visibility: visibility})

	if visibility != "direct" do
	assert Visibility.visible_for_user?(post_activity, follower)
	end

	if visibility in ["direct", "private"] do
	refute Visibility.visible_for_user?(post_activity, unrelated_user)
	end

	{:ok, _react_activity} = CommonAPI.react_with_emoji(post_activity.id, follower, "🐾")

	{post_activity, poster, follower, unrelated_user}
	end

	defp prepare_conn_of_user(conn, user) do
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["write", "read"]))
	end

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

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

	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/\u26A0")
	\|> json_response_and_validate_schema(200)

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

	assert result["pleroma"]["emoji_reactions"] == [
	%{
	"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)

	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",
	+ "url" => "http://localhost:4001/emoji/dino%20walking.gif",
	"account_ids" => [other_user.id]
	}
	]

	# Reacting with a remote emoji
	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [
	["👍", [other_user.ap_id], nil],
	["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"] == [
	%{
	"account_ids" => [other_user.id],
	"count" => 1,
	"me" => false,
	"name" => "👍",
	"url" => nil
	},
	%{
	"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 "PUT /api/v1/pleroma/statuses/:id/reactions/:emoji not allowed for non-visible posts", %{
	conn: conn
	} do
	{%{id: activity_id} = _activity, _author, follower, stranger} = prepare_reacted_post()

	# Works for follower
	resp =
	prepare_conn_of_user(conn, follower)
	\|> put("/api/v1/pleroma/statuses/#{activity_id}/reactions/🐈")
	\|> json_response_and_validate_schema(200)

	assert match?(%{"id" => ^activity_id}, resp)

	# Fails for stranger
	resp =
	prepare_conn_of_user(conn, stranger)
	\|> put("/api/v1/pleroma/statuses/#{activity_id}/reactions/🐈")
	\|> json_response_and_validate_schema(404)

	assert match?(%{"error" => "Record not found"}, resp)
	end

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

	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"] == 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 "DELETE /api/v1/pleroma/statuses/:id/reactions/:emoji only allows original reacter to revoke",
	%{conn: conn} do
	{%{id: activity_id} = _activity, author, follower, unrelated} = prepare_reacted_post("public")

	# Works for original reacter
	prepare_conn_of_user(conn, follower)
	\|> delete("/api/v1/pleroma/statuses/#{activity_id}/reactions/🐾")
	\|> json_response_and_validate_schema(200)

	# Fails for anyone else
	for u <- [author, unrelated] do
	resp =
	prepare_conn_of_user(conn, u)
	\|> delete("/api/v1/pleroma/statuses/#{activity_id}/reactions/🐾")
	\|> json_response(400)

	assert match?(%{"error" => _}, resp)
	end
	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 legacy format", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [["😿", [other_user.ap_id]]]
	}
	)

	activity = insert(:note_activity, user: user, note: note)

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

	other_user_id = other_user.id

	assert [
	%{
	"name" => "😿",
	"count" => 1,
	"me" => false,
	"url" => nil,
	"accounts" => [%{"id" => ^other_user_id}]
	}
	] = 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 not allowed for non-visible posts", %{
	conn: conn
	} do
	{%{id: activity_id} = _activity, _author, follower, stranger} = prepare_reacted_post()

	# Works for follower
	resp =
	prepare_conn_of_user(conn, follower)
	\|> get("/api/v1/pleroma/statuses/#{activity_id}/reactions")
	\|> json_response_and_validate_schema(200)

	assert match?([%{"name" => _, "count" => _} \| _], resp)

	# Fails for stranger
	assert prepare_conn_of_user(conn, stranger)
	\|> get("/api/v1/pleroma/statuses/#{activity_id}/reactions")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	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

	test "GET /api/v1/pleroma/statuses/:id/reactions/:emoji not allowed for non-visible posts", %{
	conn: conn
	} do
	{%{id: activity_id} = _activity, _author, follower, stranger} = prepare_reacted_post()

	# Works for follower
	assert prepare_conn_of_user(conn, follower)
	\|> get("/api/v1/pleroma/statuses/#{activity_id}/reactions/🐈")
	\|> json_response_and_validate_schema(200)

	# Fails for stranger
	assert prepare_conn_of_user(conn, stranger)
	\|> get("/api/v1/pleroma/statuses/#{activity_id}/reactions/🐈")
	\|> json_response_and_validate_schema(404) == %{"error" => "Record not found"}
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 9, 8:02 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1784540
Default Alt Text: (216 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions