No OneTemporary
Actions

Size

458 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/.dialyzer_ignore.exs b/.dialyzer_ignore.exs
	new file mode 100644
	index 000000000..865e7d782
	--- /dev/null
	+++ b/.dialyzer_ignore.exs
	@@ -0,0 +1,6 @@
	+[
	+{"lib/cachex.ex", "Unknown type: Spec.cache/0."},
	+{"lib/pleroma/web/plugs/rate_limiter.ex", "The pattern can never match the type {:commit, _} \| {:ignore, _}."},
	+{"lib/pleroma/web/plugs/rate_limiter.ex", "Function get_scale/2 will never be called."},
	+{"lib/pleroma/web/plugs/rate_limiter.ex", "Function initialize_buckets!/1 will never be called."}
	+]
	diff --git a/changelog.d/mastodon_directory.fix b/changelog.d/mastodon_directory.fix
	new file mode 100644
	index 000000000..937c8f864
	--- /dev/null
	+++ b/changelog.d/mastodon_directory.fix
	@@ -0,0 +1 @@
	+Mastodon API /api/v1/directory: Fix listing directory contents when not authenticated
	diff --git a/lib/pleroma/emoji.ex b/lib/pleroma/emoji.ex
	index 48302f396..96937c1c1 100644
	--- a/lib/pleroma/emoji.ex
	+++ b/lib/pleroma/emoji.ex
	@@ -1,209 +1,209 @@
	# 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

	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()) :: String.t() \| nil
	+ @spec get(String.t()) :: Pleroma.Emoji.t() \| nil
	def get(name) do
	name = maybe_strip_name(name)

	case :ets.lookup(@ets, name) do
	- [{_, path}] -> path
	+ [{_, 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 is_unicode_emoji?(unquote(emoji)), do: true
	end

	def is_unicode_emoji?(_), do: false

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

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

	def is_custom_emoji?(_), 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 is_unicode_emoji?(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

	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/gun/connection_pool/reclaimer.ex b/lib/pleroma/gun/connection_pool/reclaimer.ex
	index efd5c9fb8..35e7f4b2e 100644
	--- a/lib/pleroma/gun/connection_pool/reclaimer.ex
	+++ b/lib/pleroma/gun/connection_pool/reclaimer.ex
	@@ -1,89 +1,89 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Gun.ConnectionPool.Reclaimer do
	use GenServer, restart: :temporary

	defp registry, do: Pleroma.Gun.ConnectionPool

	def start_monitor do
	pid =
	- case :gen_server.start(__MODULE__, [], name: {:via, Registry, {registry(), "reclaimer"}}) do
	+ case GenServer.start_link(__MODULE__, [], name: {:via, Registry, {registry(), "reclaimer"}}) do
	{:ok, pid} ->
	pid

	{:error, {:already_registered, pid}} ->
	pid
	end

	{pid, Process.monitor(pid)}
	end

	@impl true
	def init(_) do
	{:ok, nil, {:continue, :reclaim}}
	end

	@impl true
	def handle_continue(:reclaim, _) do
	max_connections = Pleroma.Config.get([:connections_pool, :max_connections])

	reclaim_max =
	[:connections_pool, :reclaim_multiplier]
	\|> Pleroma.Config.get()
	\|> Kernel.*(max_connections)
	\|> round
	\|> max(1)

	:telemetry.execute([:pleroma, :connection_pool, :reclaim, :start], %{}, %{
	max_connections: max_connections,
	reclaim_max: reclaim_max
	})

	# :ets.fun2ms(
	# fn {_, {worker_pid, {_, used_by, crf, last_reference}}} when used_by == [] ->
	# {worker_pid, crf, last_reference} end)
	unused_conns =
	Registry.select(
	registry(),
	[
	{{:_, :"$1", {:_, :"$2", :"$3", :"$4"}}, [{:==, :"$2", []}], [{{:"$1", :"$3", :"$4"}}]}
	]
	)

	case unused_conns do
	[] ->
	:telemetry.execute(
	[:pleroma, :connection_pool, :reclaim, :stop],
	%{reclaimed_count: 0},
	%{
	max_connections: max_connections
	}
	)

	{:stop, :no_unused_conns, nil}

	unused_conns ->
	reclaimed =
	unused_conns
	\|> Enum.sort(fn {_pid1, crf1, last_reference1}, {_pid2, crf2, last_reference2} ->
	crf1 <= crf2 and last_reference1 <= last_reference2
	end)
	\|> Enum.take(reclaim_max)

	reclaimed
	\|> Enum.each(fn {pid, _, _} ->
	DynamicSupervisor.terminate_child(Pleroma.Gun.ConnectionPool.WorkerSupervisor, pid)
	end)

	:telemetry.execute(
	[:pleroma, :connection_pool, :reclaim, :stop],
	%{reclaimed_count: Enum.count(reclaimed)},
	%{max_connections: max_connections}
	)

	{:stop, :normal, nil}
	end
	end
	end
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index f2ba24abf..55b646b12 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,503 +1,503 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object do
	use Ecto.Schema

	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Hashtag
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.ObjectTombstone
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Workers.AttachmentsCleanupWorker

	require Logger

	@type t() :: %__MODULE__{}

	@derive {Jason.Encoder, only: [:data]}

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)

	schema "objects" do
	field(:data, :map)

	many_to_many(:hashtags, Hashtag, join_through: "hashtags_objects", on_replace: :delete)

	timestamps()
	end

	def with_joined_activity(query, activity_type \\ "Create", join_type \\ :inner) do
	object_position = Map.get(query.aliases, :object, 0)

	join(query, join_type, [{object, object_position}], a in Activity,
	on:
	fragment(
	"associated_object_id(?) = (? ->> 'id') AND (?->>'type' = ?) ",
	a.data,
	object.data,
	a.data,
	^activity_type
	),
	as: :object_activity
	)
	end

	def create(data) do
	%Object{}
	\|> Object.change(%{data: data})
	\|> Repo.insert()
	end

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :objects_unique_apid_index)
	# Expecting `maybe_handle_hashtags_change/1` to run last:
	\|> maybe_handle_hashtags_change(struct)
	end

	# Note: not checking activity type (assuming non-legacy objects are associated with Create act.)
	defp maybe_handle_hashtags_change(changeset, struct) do
	with %Ecto.Changeset{valid?: true} <- changeset,
	data_hashtags_change = get_change(changeset, :data),
	{_, true} <- {:changed, hashtags_changed?(struct, data_hashtags_change)},
	{:ok, hashtag_records} <-
	data_hashtags_change
	\|> object_data_hashtags()
	\|> Hashtag.get_or_create_by_names() do
	put_assoc(changeset, :hashtags, hashtag_records)
	else
	%{valid?: false} ->
	changeset

	{:changed, false} ->
	changeset

	{:error, _} ->
	validate_change(changeset, :data, fn _, _ ->
	[data: "error referencing hashtags"]
	end)
	end
	end

	defp hashtags_changed?(%Object{} = struct, %{"tag" => _} = data) do
	Enum.sort(embedded_hashtags(struct)) !=
	Enum.sort(object_data_hashtags(data))
	end

	defp hashtags_changed?(_, _), do: false

	def get_by_id(nil), do: nil
	def get_by_id(id), do: Repo.get(Object, id)

	def get_by_id_and_maybe_refetch(id, opts \\ []) do
	%{updated_at: updated_at} = object = get_by_id(id)

	if opts[:interval] &&
	NaiveDateTime.diff(NaiveDateTime.utc_now(), updated_at) > opts[:interval] do
	case Fetcher.refetch_object(object) do
	{:ok, %Object{} = object} ->
	object

	e ->
	Logger.error("Couldn't refresh #{object.data["id"]}:\n#{inspect(e)}")
	object
	end
	else
	object
	end
	end

	def get_by_ap_id(nil), do: nil

	def get_by_ap_id(ap_id) do
	Repo.one(from(object in Object, where: fragment("(?)->>'id' = ?", object.data, ^ap_id)))
	end

	@doc """
	Get a single attachment by it's name and href
	"""
	@spec get_attachment_by_name_and_href(String.t(), String.t()) :: Object.t() \| nil
	def get_attachment_by_name_and_href(name, href) do
	query =
	from(o in Object,
	where: fragment("(?)->>'name' = ?", o.data, ^name),
	where: fragment("(?)->>'href' = ?", o.data, ^href)
	)

	Repo.one(query)
	end

	defp warn_on_no_object_preloaded(ap_id) do
	"Object.normalize() called without preloaded object (#{inspect(ap_id)}). Consider preloading the object"
	\|> Logger.debug()

	Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")
	end

	def normalize(_, options \\ [fetch: false, id_only: false])

	# If we pass an Activity to Object.normalize(), we can try to use the preloaded object.
	# Use this whenever possible, especially when walking graphs in an O(N) loop!
	def normalize(%Object{} = object, _), do: object
	def normalize(%Activity{object: %Object{} = object}, _), do: object

	# A hack for fake activities
	def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}, _) do
	%Object{id: "pleroma:fake_object_id", data: data}
	end

	# No preloaded object
	def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, options) do
	warn_on_no_object_preloaded(ap_id)
	normalize(ap_id, options)
	end

	# No preloaded object
	def normalize(%Activity{data: %{"object" => ap_id}}, options) do
	warn_on_no_object_preloaded(ap_id)
	normalize(ap_id, options)
	end

	# Old way, try fetching the object through cache.
	def normalize(%{"id" => ap_id}, options), do: normalize(ap_id, options)

	def normalize(ap_id, options) when is_binary(ap_id) do
	cond do
	Keyword.get(options, :id_only) ->
	ap_id

	Keyword.get(options, :fetch) ->
	case Fetcher.fetch_object_from_id(ap_id, options) do
	{:ok, object} -> object
	_ -> nil
	end

	true ->
	get_cached_by_ap_id(ap_id)
	end
	end

	def normalize(_, _), do: nil

	# Owned objects can only be accessed by their owner
	def authorize_access(%Object{data: %{"actor" => actor}}, %User{ap_id: ap_id}) do
	if actor == ap_id do
	:ok
	else
	{:error, :forbidden}
	end
	end

	# Legacy objects can be accessed by anybody
	def authorize_access(%Object{}, %User{}), do: :ok

	@spec get_cached_by_ap_id(String.t()) :: Object.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "object:#{ap_id}"

	with {:ok, nil} <- @cachex.get(:object_cache, key),
	object when not is_nil(object) <- get_by_ap_id(ap_id),
	{:ok, true} <- @cachex.put(:object_cache, key, object) do
	object
	else
	{:ok, object} -> object
	nil -> nil
	end
	end

	def make_tombstone(%Object{data: %{"id" => id, "type" => type}}, deleted \\ DateTime.utc_now()) do
	%ObjectTombstone{
	id: id,
	formerType: type,
	deleted: deleted
	}
	\|> Map.from_struct()
	end

	def swap_object_with_tombstone(object) do
	tombstone = make_tombstone(object)

	with {:ok, object} <-
	object
	\|> Object.change(%{data: tombstone})
	\|> Repo.update() do
	Hashtag.unlink(object)
	{:ok, object}
	end
	end

	def delete(%Object{data: %{"id" => id}} = object) do
	with {:ok, _obj} = swap_object_with_tombstone(object),
	deleted_activity = Activity.delete_all_by_object_ap_id(id),
	{:ok, _} <- invalid_object_cache(object) do
	cleanup_attachments(
	Config.get([:instance, :cleanup_attachments]),
	- %{"object" => object}
	+ object
	)

	{:ok, object, deleted_activity}
	end
	end

	- @spec cleanup_attachments(boolean(), %{required(:object) => map()}) ::
	+ @spec cleanup_attachments(boolean(), Object.t()) ::
	{:ok, Oban.Job.t() \| nil}
	- def cleanup_attachments(true, %{"object" => _} = params) do
	- AttachmentsCleanupWorker.enqueue("cleanup_attachments", params)
	+ def cleanup_attachments(true, %Object{} = object) do
	+ AttachmentsCleanupWorker.enqueue("cleanup_attachments", %{"object" => object})
	end

	def cleanup_attachments(_, _), do: {:ok, nil}

	def prune(%Object{data: %{"id" => _id}} = object) do
	with {:ok, object} <- Repo.delete(object),
	{:ok, _} <- invalid_object_cache(object) do
	{:ok, object}
	end
	end

	def invalid_object_cache(%Object{data: %{"id" => id}}) do
	with {:ok, true} <- @cachex.del(:object_cache, "object:#{id}") do
	@cachex.del(:web_resp_cache, URI.parse(id).path)
	end
	end

	def set_cache(%Object{data: %{"id" => ap_id}} = object) do
	@cachex.put(:object_cache, "object:#{ap_id}", object)
	{:ok, object}
	end

	def update_and_set_cache(changeset) do
	with {:ok, object} <- Repo.update(changeset) do
	set_cache(object)
	end
	end

	def increase_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{repliesCount}',
	(coalesce((?->>'repliesCount')::int, 0) + 1)::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	defp poll_is_multiple?(%Object{data: %{"anyOf" => [_ \| _]}}), do: true

	defp poll_is_multiple?(_), do: false

	def decrease_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{repliesCount}',
	(greatest(0, (?->>'repliesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def increase_quotes_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{quotesCount}',
	(coalesce((?->>'quotesCount')::int, 0) + 1)::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def decrease_quotes_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{quotesCount}',
	(greatest(0, (?->>'quotesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def increase_vote_count(ap_id, name, actor) do
	with %Object{} = object <- Object.normalize(ap_id, fetch: false),
	"Question" <- object.data["type"] do
	key = if poll_is_multiple?(object), do: "anyOf", else: "oneOf"

	options =
	object.data[key]
	\|> Enum.map(fn
	%{"name" => ^name} = option ->
	Kernel.update_in(option["replies"]["totalItems"], &(&1 + 1))

	option ->
	option
	end)

	voters = [actor \| object.data["voters"] \|\| []] \|> Enum.uniq()

	data =
	object.data
	\|> Map.put(key, options)
	\|> Map.put("voters", voters)

	object
	\|> Object.change(%{data: data})
	\|> update_and_set_cache()
	else
	_ -> :noop
	end
	end

	@doc "Updates data field of an object"
	def update_data(%Object{data: data} = object, attrs \\ %{}) do
	object
	\|> Object.change(%{data: Map.merge(data \|\| %{}, attrs)})
	\|> Repo.update()
	end

	def local?(%Object{data: %{"id" => id}}) do
	String.starts_with?(id, Pleroma.Web.Endpoint.url() <> "/")
	end

	def replies(object, opts \\ []) do
	object = Object.normalize(object, fetch: false)

	query =
	Object
	\|> where(
	[o],
	fragment("(?)->>'inReplyTo' = ?", o.data, ^object.data["id"])
	)
	\|> order_by([o], asc: o.id)

	if opts[:self_only] do
	actor = object.data["actor"]
	where(query, [o], fragment("(?)->>'actor' = ?", o.data, ^actor))
	else
	query
	end
	end

	def self_replies(object, opts \\ []),
	do: replies(object, Keyword.put(opts, :self_only, true))

	def tags(%Object{data: %{"tag" => tags}}) when is_list(tags), do: tags

	def tags(_), do: []

	def hashtags(%Object{} = object) do
	# Note: always using embedded hashtags regardless whether they are migrated to hashtags table
	# (embedded hashtags stay in sync anyways, and we avoid extra joins and preload hassle)
	embedded_hashtags(object)
	end

	def embedded_hashtags(%Object{data: data}) do
	object_data_hashtags(data)
	end

	def embedded_hashtags(_), do: []

	def object_data_hashtags(%{"tag" => tags}) when is_list(tags) do
	tags
	\|> Enum.filter(fn
	%{"type" => "Hashtag"} = data -> Map.has_key?(data, "name")
	plain_text when is_bitstring(plain_text) -> true
	_ -> false
	end)
	\|> Enum.map(fn
	%{"name" => "#" <> hashtag} -> String.downcase(hashtag)
	%{"name" => hashtag} -> String.downcase(hashtag)
	hashtag when is_bitstring(hashtag) -> String.downcase(hashtag)
	end)
	\|> Enum.uniq()
	# Note: "" elements (plain text) might occur in `data.tag` for incoming objects
	\|> Enum.filter(&(&1 not in [nil, ""]))
	end

	def object_data_hashtags(_), do: []

	def get_emoji_reactions(object) do
	reactions = object.data["reactions"]

	if is_list(reactions) or is_map(reactions) do
	reactions
	\|> Enum.map(fn
	[_emoji, users, _maybe_url] = item when is_list(users) ->
	item

	[emoji, users] when is_list(users) ->
	[emoji, users, nil]

	# This case is here to process the Map situation, which will happen
	# only with the legacy two-value format.
	{emoji, users} when is_list(users) ->
	[emoji, users, nil]

	_ ->
	nil
	end)
	\|> Enum.reject(&is_nil/1)
	else
	[]
	end
	end
	end
	diff --git a/lib/pleroma/reverse_proxy.ex b/lib/pleroma/reverse_proxy.ex
	index ec7732946..cc4530010 100644
	--- a/lib/pleroma/reverse_proxy.ex
	+++ b/lib/pleroma/reverse_proxy.ex
	@@ -1,426 +1,420 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ReverseProxy do
	@range_headers ~w(range if-range)
	@keep_req_headers ~w(accept accept-encoding cache-control if-modified-since) ++
	~w(if-unmodified-since if-none-match) ++ @range_headers
	@resp_cache_headers ~w(etag date last-modified)
	@keep_resp_headers @resp_cache_headers ++
	~w(content-length content-type content-disposition content-encoding) ++
	~w(content-range accept-ranges vary)
	@default_cache_control_header "public, max-age=1209600"
	@valid_resp_codes [200, 206, 304]
	@max_read_duration :timer.seconds(30)
	@max_body_length :infinity
	@failed_request_ttl :timer.seconds(60)
	@methods ~w(GET HEAD)

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)

	def max_read_duration_default, do: @max_read_duration
	def default_cache_control_header, do: @default_cache_control_header

	@moduledoc """
	A reverse proxy.

	Pleroma.ReverseProxy.call(conn, url, options)

	It is not meant to be added into a plug pipeline, but to be called from another plug or controller.

	Supports `#{inspect(@methods)}` HTTP methods, and only allows `#{inspect(@valid_resp_codes)}` status codes.

	Responses are chunked to the client while downloading from the upstream.

	Some request / responses headers are preserved:

	* request: `#{inspect(@keep_req_headers)}`
	* response: `#{inspect(@keep_resp_headers)}`

	Options:

	* `redirect_on_failure` (default `false`). Redirects the client to the real remote URL if there's any HTTP
	errors. Any error during body processing will not be redirected as the response is chunked. This may expose
	remote URL, clients IPs, ….

	* `max_body_length` (default `#{inspect(@max_body_length)}`): limits the content length to be approximately the
	specified length. It is validated with the `content-length` header and also verified when proxying.

	* `max_read_duration` (default `#{inspect(@max_read_duration)}` ms): the total time the connection is allowed to
	read from the remote upstream.

	* `failed_request_ttl` (default `#{inspect(@failed_request_ttl)}` ms): the time the failed request is cached and cannot be retried.

	* `inline_content_types`:
	* `true` will not alter `content-disposition` (up to the upstream),
	* `false` will add `content-disposition: attachment` to any request,
	* a list of whitelisted content types

	* `req_headers`, `resp_headers` additional headers.

	* `http`: options for [hackney](https://github.com/benoitc/hackney) or [gun](https://github.com/ninenines/gun).

	"""
	@default_options [pool: :media]

	@inline_content_types [
	"image/gif",
	"image/jpeg",
	"image/jpg",
	"image/png",
	"image/svg+xml",
	"audio/mpeg",
	"audio/mp3",
	"video/webm",
	"video/mp4",
	"video/quicktime"
	]

	require Logger
	import Plug.Conn

	@type option() ::
	{:max_read_duration, non_neg_integer() \| :infinity}
	\| {:max_body_length, non_neg_integer() \| :infinity}
	\| {:failed_request_ttl, non_neg_integer() \| :infinity}
	- \| {:http, []}
	+ \| {:http, keyword()}
	\| {:req_headers, [{String.t(), String.t()}]}
	\| {:resp_headers, [{String.t(), String.t()}]}
	- \| {:inline_content_types, boolean() \| [String.t()]}
	+ \| {:inline_content_types, boolean() \| list(String.t())}
	\| {:redirect_on_failure, boolean()}

	- @spec call(Plug.Conn.t(), url :: String.t(), [option()]) :: Plug.Conn.t()
	+ @spec call(Plug.Conn.t(), String.t(), list(option())) :: Plug.Conn.t()
	def call(_conn, _url, _opts \\ [])

	def call(conn = %{method: method}, url, opts) when method in @methods do
	client_opts = Keyword.merge(@default_options, Keyword.get(opts, :http, []))

	req_headers = build_req_headers(conn.req_headers, opts)

	opts =
	if filename = Pleroma.Web.MediaProxy.filename(url) do
	Keyword.put_new(opts, :attachment_name, filename)
	else
	opts
	end

	with {:ok, nil} <- @cachex.get(:failed_proxy_url_cache, url),
	{:ok, code, headers, client} <- request(method, url, req_headers, client_opts),
	:ok <-
	header_length_constraint(
	headers,
	Keyword.get(opts, :max_body_length, @max_body_length)
	) do
	response(conn, client, url, code, headers, opts)
	else
	{:ok, true} ->
	conn
	\|> error_or_redirect(url, 500, "Request failed", opts)
	\|> halt()

	{:ok, code, headers} ->
	head_response(conn, url, code, headers, opts)
	\|> halt()

	{:error, {:invalid_http_response, code}} ->
	Logger.error("#{__MODULE__}: request to #{inspect(url)} failed with HTTP status #{code}")
	track_failed_url(url, code, opts)

	conn
	\|> error_or_redirect(
	url,
	code,
	"Request failed: " <> Plug.Conn.Status.reason_phrase(code),
	opts
	)
	\|> halt()

	{:error, error} ->
	Logger.error("#{__MODULE__}: request to #{inspect(url)} failed: #{inspect(error)}")
	track_failed_url(url, error, opts)

	conn
	\|> error_or_redirect(url, 500, "Request failed", opts)
	\|> halt()
	end
	end

	def call(conn, _, _) do
	conn
	\|> send_resp(400, Plug.Conn.Status.reason_phrase(400))
	\|> halt()
	end

	defp request(method, url, headers, opts) do
	Logger.debug("#{__MODULE__} #{method} #{url} #{inspect(headers)}")
	method = method \|> String.downcase() \|> String.to_existing_atom()

	case client().request(method, url, headers, "", opts) do
	{:ok, code, headers, client} when code in @valid_resp_codes ->
	{:ok, code, downcase_headers(headers), client}

	{:ok, code, headers} when code in @valid_resp_codes ->
	{:ok, code, downcase_headers(headers)}

	{:ok, code, _, _} ->
	{:error, {:invalid_http_response, code}}

	{:ok, code, _} ->
	{:error, {:invalid_http_response, code}}

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

	defp response(conn, client, url, status, headers, opts) do
	Logger.debug("#{__MODULE__} #{status} #{url} #{inspect(headers)}")

	result =
	conn
	\|> put_resp_headers(build_resp_headers(headers, opts))
	\|> send_chunked(status)
	\|> chunk_reply(client, opts)

	case result do
	{:ok, conn} ->
	halt(conn)

	{:error, :closed, conn} ->
	client().close(client)
	halt(conn)

	{:error, error, conn} ->
	Logger.warning(
	"#{__MODULE__} request to #{url} failed while reading/chunking: #{inspect(error)}"
	)

	client().close(client)
	halt(conn)
	end
	end

	defp chunk_reply(conn, client, opts) do
	chunk_reply(conn, client, opts, 0, 0)
	end

	defp chunk_reply(conn, client, opts, sent_so_far, duration) do
	with {:ok, duration} <-
	check_read_duration(
	duration,
	Keyword.get(opts, :max_read_duration, @max_read_duration)
	),
	{:ok, data, client} <- client().stream_body(client),
	{:ok, duration} <- increase_read_duration(duration),
	sent_so_far = sent_so_far + byte_size(data),
	:ok <-
	body_size_constraint(
	sent_so_far,
	Keyword.get(opts, :max_body_length, @max_body_length)
	),
	{:ok, conn} <- chunk(conn, data) do
	chunk_reply(conn, client, opts, sent_so_far, duration)
	else
	:done -> {:ok, conn}
	{:error, error} -> {:error, error, conn}
	end
	end

	defp head_response(conn, url, code, headers, opts) do
	Logger.debug("#{__MODULE__} #{code} #{url} #{inspect(headers)}")

	conn
	\|> put_resp_headers(build_resp_headers(headers, opts))
	\|> send_resp(code, "")
	end

	defp error_or_redirect(conn, url, code, body, opts) do
	if Keyword.get(opts, :redirect_on_failure, false) do
	conn
	\|> Phoenix.Controller.redirect(external: url)
	\|> halt()
	else
	conn
	\|> send_resp(code, body)
	\|> halt
	end
	end

	defp downcase_headers(headers) do
	Enum.map(headers, fn {k, v} ->
	{String.downcase(k), v}
	end)
	end

	defp get_content_type(headers) do
	{_, content_type} =
	List.keyfind(headers, "content-type", 0, {"content-type", "application/octet-stream"})

	[content_type \| _] = String.split(content_type, ";")
	content_type
	end

	defp put_resp_headers(conn, headers) do
	Enum.reduce(headers, conn, fn {k, v}, conn ->
	put_resp_header(conn, k, v)
	end)
	end

	defp build_req_headers(headers, opts) do
	headers
	\|> downcase_headers()
	\|> Enum.filter(fn {k, _} -> k in @keep_req_headers end)
	\|> build_req_range_or_encoding_header(opts)
	\|> build_req_user_agent_header(opts)
	\|> Keyword.merge(Keyword.get(opts, :req_headers, []))
	end

	# Disable content-encoding if any @range_headers are requested (see #1823).
	defp build_req_range_or_encoding_header(headers, _opts) do
	range? = Enum.any?(headers, fn {header, _} -> Enum.member?(@range_headers, header) end)

	if range? && List.keymember?(headers, "accept-encoding", 0) do
	List.keydelete(headers, "accept-encoding", 0)
	else
	headers
	end
	end

	defp build_req_user_agent_header(headers, _opts) do
	List.keystore(
	headers,
	"user-agent",
	0,
	{"user-agent", Pleroma.Application.user_agent()}
	)
	end

	defp build_resp_headers(headers, opts) do
	headers
	\|> Enum.filter(fn {k, _} -> k in @keep_resp_headers end)
	\|> build_resp_cache_headers(opts)
	\|> build_resp_content_disposition_header(opts)
	\|> Keyword.merge(Keyword.get(opts, :resp_headers, []))
	end

	defp build_resp_cache_headers(headers, _opts) do
	has_cache? = Enum.any?(headers, fn {k, _} -> k in @resp_cache_headers end)

	cond do
	has_cache? ->
	# There's caching header present but no cache-control -- we need to set our own
	# as Plug defaults to "max-age=0, private, must-revalidate"
	List.keystore(
	headers,
	"cache-control",
	0,
	{"cache-control", @default_cache_control_header}
	)

	true ->
	List.keystore(
	headers,
	"cache-control",
	0,
	{"cache-control", @default_cache_control_header}
	)
	end
	end

	defp build_resp_content_disposition_header(headers, opts) do
	opt = Keyword.get(opts, :inline_content_types, @inline_content_types)

	content_type = get_content_type(headers)

	attachment? =
	cond do
	is_list(opt) && !Enum.member?(opt, content_type) -> true
	opt == false -> true
	true -> false
	end

	if attachment? do
	name =
	try do
	{{"content-disposition", content_disposition_string}, _} =
	List.keytake(headers, "content-disposition", 0)

	[name \| _] =
	Regex.run(
	~r/filename="((?:[^"\\]\|\\.)*)"/u,
	content_disposition_string \|\| "",
	capture: :all_but_first
	)

	name
	rescue
	MatchError -> Keyword.get(opts, :attachment_name, "attachment")
	end

	disposition = "attachment; filename=\"#{name}\""

	List.keystore(headers, "content-disposition", 0, {"content-disposition", disposition})
	else
	headers
	end
	end

	defp header_length_constraint(headers, limit) when is_integer(limit) and limit > 0 do
	with {_, size} <- List.keyfind(headers, "content-length", 0),
	{size, _} <- Integer.parse(size),
	true <- size <= limit do
	:ok
	else
	false ->
	{:error, :body_too_large}

	_ ->
	:ok
	end
	end

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

	defp body_size_constraint(size, limit) when is_integer(limit) and limit > 0 and size >= limit do
	{:error, :body_too_large}
	end

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

	- defp check_read_duration(nil = _duration, max), do: check_read_duration(@max_read_duration, max)
	-
	defp check_read_duration(duration, max)
	when is_integer(duration) and is_integer(max) and max > 0 do
	if duration > max do
	{:error, :read_duration_exceeded}
	else
	{:ok, {duration, :erlang.system_time(:millisecond)}}
	end
	end

	defp check_read_duration(_, _), do: {:ok, :no_duration_limit, :no_duration_limit}

	defp increase_read_duration({previous_duration, started})
	when is_integer(previous_duration) and is_integer(started) do
	duration = :erlang.system_time(:millisecond) - started
	{:ok, previous_duration + duration}
	end

	- defp increase_read_duration(_) do
	- {:ok, :no_duration_limit, :no_duration_limit}
	- end
	-
	defp client, do: Pleroma.ReverseProxy.Client.Wrapper

	defp track_failed_url(url, error, opts) do
	ttl =
	unless error in [:body_too_large, 400, 204] do
	Keyword.get(opts, :failed_request_ttl, @failed_request_ttl)
	else
	nil
	end

	@cachex.put(:failed_proxy_url_cache, url, true, ttl: ttl)
	end
	end
	diff --git a/lib/pleroma/upload.ex b/lib/pleroma/upload.ex
	index 89cd3d920..e6c484548 100644
	--- a/lib/pleroma/upload.ex
	+++ b/lib/pleroma/upload.ex
	@@ -1,283 +1,284 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload do
	@moduledoc """
	Manage user uploads

	Options:
	* `:type`: presets for activity type (defaults to Document) and size limits from app configuration
	* `:description`: upload alternative text
	* `:base_url`: override base url
	* `:uploader`: override uploader
	* `:filters`: override filters
	* `:size_limit`: override size limit
	* `:activity_type`: override activity type

	The `%Pleroma.Upload{}` struct: all documented fields are meant to be overwritten in filters:

	* `:id` - the upload id.
	* `:name` - the upload file name.
	* `:path` - the upload path: set at first to `id/name` but can be changed. Keep in mind that the path
	is once created permanent and changing it (especially in uploaders) is probably a bad idea!
	* `:tempfile` - path to the temporary file. Prefer in-place changes on the file rather than changing the
	path as the temporary file is also tracked by `Plug.Upload{}` and automatically deleted once the request is over.
	* `:width` - width of the media in pixels
	* `:height` - height of the media in pixels
	* `:blurhash` - string hash of the image encoded with the blurhash algorithm (https://blurha.sh/)

	Related behaviors:

	* `Pleroma.Uploaders.Uploader`
	* `Pleroma.Upload.Filter`

	"""
	alias Ecto.UUID
	alias Pleroma.Maps
	alias Pleroma.Web.ActivityPub.Utils
	require Logger

	@type source ::
	Plug.Upload.t()
	\| (data_uri_string :: String.t())
	\| {:from_local, name :: String.t(), id :: String.t(), path :: String.t()}
	\| map()

	@type option ::
	{:type, :avatar \| :banner \| :background}
	\| {:description, String.t()}
	\| {:activity_type, String.t()}
	\| {:size_limit, nil \| non_neg_integer()}
	\| {:uploader, module()}
	\| {:filters, [module()]}
	+ \| {:actor, String.t()}

	@type t :: %__MODULE__{
	id: String.t(),
	name: String.t(),
	tempfile: String.t(),
	content_type: String.t(),
	width: integer(),
	height: integer(),
	blurhash: String.t(),
	description: String.t(),
	path: String.t()
	}
	defstruct [
	:id,
	:name,
	:tempfile,
	:content_type,
	:width,
	:height,
	:blurhash,
	:description,
	:path
	]

	@config_impl Application.compile_env(:pleroma, [__MODULE__, :config_impl], Pleroma.Config)

	defp get_description(upload) do
	case {upload.description, Pleroma.Config.get([Pleroma.Upload, :default_description])} do
	{description, _} when is_binary(description) -> description
	{_, :filename} -> upload.name
	{_, str} when is_binary(str) -> str
	_ -> ""
	end
	end

	@spec store(source, options :: [option()]) :: {:ok, map()} \| {:error, any()}
	@doc "Store a file. If using a `Plug.Upload{}` as the source, be sure to use `Majic.Plug` to ensure its content_type and filename is correct."
	def store(upload, opts \\ []) do
	opts = get_opts(opts)

	with {:ok, upload} <- prepare_upload(upload, opts),
	upload = %__MODULE__{upload \| path: upload.path \|\| "#{upload.id}/#{upload.name}"},
	{:ok, upload} <- Pleroma.Upload.Filter.filter(opts.filters, upload),
	description = get_description(upload),
	{_, true} <-
	{:description_limit,
	String.length(description) <= Pleroma.Config.get([:instance, :description_limit])},
	{:ok, url_spec} <- Pleroma.Uploaders.Uploader.put_file(opts.uploader, upload) do
	{:ok,
	%{
	"id" => Utils.generate_object_id(),
	"type" => opts.activity_type,
	"mediaType" => upload.content_type,
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => upload.content_type,
	"href" => url_from_spec(upload, opts.base_url, url_spec)
	}
	\|> Maps.put_if_present("width", upload.width)
	\|> Maps.put_if_present("height", upload.height)
	],
	"name" => description
	}
	\|> Maps.put_if_present("blurhash", upload.blurhash)}
	else
	{:description_limit, _} ->
	{:error, :description_too_long}

	{:error, error} ->
	Logger.error(
	"#{__MODULE__} store (using #{inspect(opts.uploader)}) failed: #{inspect(error)}"
	)

	{:error, error}
	end
	end

	def char_unescaped?(char) do
	URI.char_unreserved?(char) or char == ?/
	end

	defp get_opts(opts) do
	{size_limit, activity_type} =
	case Keyword.get(opts, :type) do
	:banner ->
	{Pleroma.Config.get!([:instance, :banner_upload_limit]), "Image"}

	:avatar ->
	{Pleroma.Config.get!([:instance, :avatar_upload_limit]), "Image"}

	:background ->
	{Pleroma.Config.get!([:instance, :background_upload_limit]), "Image"}

	_ ->
	{Pleroma.Config.get!([:instance, :upload_limit]), "Document"}
	end

	%{
	activity_type: Keyword.get(opts, :activity_type, activity_type),
	size_limit: Keyword.get(opts, :size_limit, size_limit),
	uploader: Keyword.get(opts, :uploader, Pleroma.Config.get([__MODULE__, :uploader])),
	filters: Keyword.get(opts, :filters, Pleroma.Config.get([__MODULE__, :filters])),
	description: Keyword.get(opts, :description),
	base_url: base_url()
	}
	end

	defp prepare_upload(%Plug.Upload{} = file, opts) do
	with :ok <- check_file_size(file.path, opts.size_limit) do
	{:ok,
	%__MODULE__{
	id: UUID.generate(),
	name: file.filename,
	tempfile: file.path,
	content_type: file.content_type,
	description: opts.description
	}}
	end
	end

	defp prepare_upload(%{img: "data:image/" <> image_data}, opts) do
	parsed = Regex.named_captures(~r/(?<filetype>jpeg\|png\|gif);base64,(?<data>.*)/, image_data)
	data = Base.decode64!(parsed["data"], ignore: :whitespace)
	hash = Base.encode16(:crypto.hash(:sha256, data), case: :upper)

	with :ok <- check_binary_size(data, opts.size_limit),
	tmp_path <- tempfile_for_image(data),
	{:ok, %{mime_type: content_type}} <-
	Majic.perform({:bytes, data}, pool: Pleroma.MajicPool),
	[ext \| _] <- MIME.extensions(content_type) do
	{:ok,
	%__MODULE__{
	id: UUID.generate(),
	name: hash <> "." <> ext,
	tempfile: tmp_path,
	content_type: content_type,
	description: opts.description
	}}
	end
	end

	# For Mix.Tasks.MigrateLocalUploads
	defp prepare_upload(%__MODULE__{tempfile: path} = upload, _opts) do
	with {:ok, %{mime_type: content_type}} <- Majic.perform(path, pool: Pleroma.MajicPool) do
	{:ok, %__MODULE__{upload \| content_type: content_type}}
	end
	end

	defp check_binary_size(binary, size_limit)
	when is_integer(size_limit) and size_limit > 0 and byte_size(binary) >= size_limit do
	{:error, :file_too_large}
	end

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

	defp check_file_size(path, size_limit) when is_integer(size_limit) and size_limit > 0 do
	with {:ok, %{size: size}} <- File.stat(path),
	true <- size <= size_limit do
	:ok
	else
	false -> {:error, :file_too_large}
	error -> error
	end
	end

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

	# Creates a tempfile using the Plug.Upload Genserver which cleans them up
	# automatically.
	defp tempfile_for_image(data) do
	{:ok, tmp_path} = Plug.Upload.random_file("profile_pics")
	{:ok, tmp_file} = File.open(tmp_path, [:write, :raw, :binary])
	IO.binwrite(tmp_file, data)

	tmp_path
	end

	defp url_from_spec(%__MODULE__{name: name}, base_url, {:file, path}) do
	path =
	URI.encode(path, &char_unescaped?/1) <>
	if Pleroma.Config.get([__MODULE__, :link_name], false) do
	"?name=#{URI.encode(name, &char_unescaped?/1)}"
	else
	""
	end

	[base_url, path]
	\|> Path.join()
	end

	defp url_from_spec(_upload, _base_url, {:url, url}), do: url

	def base_url do
	uploader = @config_impl.get([Pleroma.Upload, :uploader])
	upload_base_url = @config_impl.get([Pleroma.Upload, :base_url])
	public_endpoint = @config_impl.get([uploader, :public_endpoint])

	case uploader do
	Pleroma.Uploaders.Local ->
	upload_base_url \|\| Pleroma.Web.Endpoint.url() <> "/media/"

	Pleroma.Uploaders.S3 ->
	bucket = @config_impl.get([Pleroma.Uploaders.S3, :bucket])
	truncated_namespace = @config_impl.get([Pleroma.Uploaders.S3, :truncated_namespace])
	namespace = @config_impl.get([Pleroma.Uploaders.S3, :bucket_namespace])

	bucket_with_namespace =
	cond do
	!is_nil(truncated_namespace) ->
	truncated_namespace

	!is_nil(namespace) ->
	namespace <> ":" <> bucket

	true ->
	bucket
	end

	if public_endpoint do
	Path.join([public_endpoint, bucket_with_namespace])
	else
	Path.join([upload_base_url, bucket_with_namespace])
	end

	_ ->
	public_endpoint \|\| upload_base_url \|\| Pleroma.Web.Endpoint.url() <> "/media/"
	end
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 89a95c435..1457c002c 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2717 +1,2720 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query
	import Ecto, only: [assoc: 2]

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Delivery
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Emoji
	alias Pleroma.FollowingRelationship
	alias Pleroma.Formatter
	alias Pleroma.HTML
	alias Pleroma.Keys
	alias Pleroma.MFA
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.RelMe
	alias Pleroma.Workers.BackgroundWorker

	require Logger
	require Pleroma.Constants

	@type t :: %__MODULE__{}
	@type account_status ::
	:active
	\| :deactivated
	\| :password_reset_pending
	\| :confirmation_pending
	\| :approval_pending
	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/

	@strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
	@extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/

	# AP ID user relationships (blocks, mutes etc.)
	# Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
	@user_relationships_config [
	block: [
	blocker_blocks: :blocked_users,
	blockee_blocks: :blocker_users
	],
	mute: [
	muter_mutes: :muted_users,
	mutee_mutes: :muter_users
	],
	reblog_mute: [
	reblog_muter_mutes: :reblog_muted_users,
	reblog_mutee_mutes: :reblog_muter_users
	],
	notification_mute: [
	notification_muter_mutes: :notification_muted_users,
	notification_mutee_mutes: :notification_muter_users
	],
	# Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
	inverse_subscription: [
	subscribee_subscriptions: :subscriber_users,
	subscriber_subscriptions: :subscribee_users
	],
	endorsement: [
	endorser_endorsements: :endorsed_users,
	endorsee_endorsements: :endorser_users
	]
	]

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)

	schema "users" do
	field(:bio, :string, default: "")
	field(:raw_bio, :string)
	field(:email, :string)
	field(:name, :string)
	field(:nickname, :string)
	field(:password_hash, :string)
	field(:password, :string, virtual: true)
	field(:password_confirmation, :string, virtual: true)
	field(:keys, :string)
	field(:public_key, :string)
	field(:ap_id, :string)
	field(:avatar, :map, default: %{})
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:featured_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	field(:banner, :map, default: %{})
	field(:background, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	field(:following_count, :integer, default: 0)
	field(:is_locked, :boolean, default: false)
	field(:is_confirmed, :boolean, default: true)
	field(:password_reset_pending, :boolean, default: false)
	field(:is_approved, :boolean, default: true)
	field(:registration_reason, :string, default: nil)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:domain_blocks, {:array, :string}, default: [])
	field(:is_active, :boolean, default: true)
	field(:no_rich_text, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	field(:uri, ObjectValidators.Uri, default: nil)
	field(:hide_followers_count, :boolean, default: false)
	field(:hide_follows_count, :boolean, default: false)
	field(:hide_followers, :boolean, default: false)
	field(:hide_follows, :boolean, default: false)
	field(:hide_favorites, :boolean, default: true)
	field(:email_notifications, :map, default: %{"digest" => false})
	field(:mascot, :map, default: nil)
	field(:emoji, :map, default: %{})
	field(:pleroma_settings_store, :map, default: %{})
	field(:fields, {:array, :map}, default: [])
	field(:raw_fields, {:array, :map}, default: [])
	field(:is_discoverable, :boolean, default: false)
	field(:invisible, :boolean, default: false)
	field(:allow_following_move, :boolean, default: true)
	field(:skip_thread_containment, :boolean, default: false)
	field(:actor_type, :string, default: "Person")
	field(:also_known_as, {:array, ObjectValidators.ObjectID}, default: [])
	field(:inbox, :string)
	field(:shared_inbox, :string)
	field(:accepts_chat_messages, :boolean, default: nil)
	field(:last_active_at, :naive_datetime)
	field(:disclose_client, :boolean, default: true)
	field(:pinned_objects, :map, default: %{})
	field(:is_suggested, :boolean, default: false)
	field(:last_status_at, :naive_datetime)
	field(:birthday, :date)
	field(:show_birthday, :boolean, default: false)
	field(:language, :string)

	embeds_one(
	:notification_settings,
	Pleroma.User.NotificationSetting,
	on_replace: :update
	)

	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	has_many(:deliveries, Delivery)

	has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
	has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)

	for {relationship_type,
	[
	{outgoing_relation, outgoing_relation_target},
	{incoming_relation, incoming_relation_source}
	]} <- @user_relationships_config do
	# Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
	# :notification_muter_mutes, :subscribee_subscriptions, :endorser_endorsements
	has_many(outgoing_relation, UserRelationship,
	foreign_key: :source_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
	# :notification_mutee_mutes, :subscriber_subscriptions, :endorsee_endorsements
	has_many(incoming_relation, UserRelationship,
	foreign_key: :target_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
	# :notification_muted_users, :subscriber_users, :endorsed_users
	has_many(outgoing_relation_target, through: [outgoing_relation, :target])

	# Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
	# :notification_muter_users, :subscribee_users, :endorser_users
	has_many(incoming_relation_source, through: [incoming_relation, :source])
	end

	# `:blocks` is deprecated (replaced with `blocked_users` relation)
	field(:blocks, {:array, :string}, default: [])
	# `:mutes` is deprecated (replaced with `muted_users` relation)
	field(:mutes, {:array, :string}, default: [])
	# `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
	field(:muted_reblogs, {:array, :string}, default: [])
	# `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
	field(:muted_notifications, {:array, :string}, default: [])
	# `:subscribers` is deprecated (replaced with `subscriber_users` relation)
	field(:subscribers, {:array, :string}, default: [])

	embeds_one(
	:multi_factor_authentication_settings,
	MFA.Settings,
	on_replace: :delete
	)

	timestamps()
	end

	for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
	@user_relationships_config do
	# `def blocked_users_relation/2`, `def muted_users_relation/2`,
	# `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
	# `def subscriber_users/2`, `def endorsed_users_relation/2`
	def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
	target_users_query = assoc(user, unquote(outgoing_relation_target))

	if restrict_deactivated? do
	target_users_query
	\|> User.Query.build(%{deactivated: false})
	else
	target_users_query
	end
	end

	# `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
	# `def notification_muted_users/2`, `def subscriber_users/2`, `def endorsed_users/2`
	def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> Repo.all()
	end

	# `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
	# `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`,
	# `def endorsed_users_ap_ids/2`
	def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end
	end

	def cached_blocked_users_ap_ids(user) do
	@cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
	blocked_users_ap_ids(user)
	end)
	end

	def cached_muted_users_ap_ids(user) do
	@cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
	muted_users_ap_ids(user)
	end)
	end

	defdelegate following_count(user), to: FollowingRelationship
	defdelegate following(user), to: FollowingRelationship
	defdelegate following?(follower, followed), to: FollowingRelationship
	defdelegate following_ap_ids(user), to: FollowingRelationship
	defdelegate get_follow_requests(user), to: FollowingRelationship
	defdelegate search(query, opts \\ []), to: User.Search

	@doc """
	Dumps Flake Id to SQL-compatible format (16-byte UUID).
	E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
	"""
	def binary_id(source_id) when is_binary(source_id) do
	with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
	dumped_id
	else
	_ -> source_id
	end
	end

	def binary_id(source_ids) when is_list(source_ids) do
	Enum.map(source_ids, &binary_id/1)
	end

	def binary_id(%User{} = user), do: binary_id(user.id)

	@doc "Returns status account"
	@spec account_status(User.t()) :: account_status()
	def account_status(%User{is_active: false}), do: :deactivated
	def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
	def account_status(%User{local: true, is_approved: false}), do: :approval_pending
	def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
	def account_status(%User{}), do: :active

	@spec visible_for(User.t(), User.t() \| nil) ::
	:visible
	\| :invisible
	\| :restricted_unauthenticated
	\| :deactivated
	\| :confirmation_pending
	def visible_for(user, for_user \\ nil)

	def visible_for(%User{invisible: true}, _), do: :invisible

	def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible

	def visible_for(%User{} = user, nil) do
	if restrict_unauthenticated?(user) do
	:restrict_unauthenticated
	else
	visible_account_status(user)
	end
	end

	def visible_for(%User{} = user, for_user) do
	if privileged?(for_user, :users_manage_activation_state) do
	:visible
	else
	visible_account_status(user)
	end
	end

	def visible_for(_, _), do: :invisible

	defp restrict_unauthenticated?(%User{local: true}) do
	Config.restrict_unauthenticated_access?(:profiles, :local)
	end

	defp restrict_unauthenticated?(%User{local: _}) do
	Config.restrict_unauthenticated_access?(:profiles, :remote)
	end

	defp visible_account_status(user) do
	status = account_status(user)

	if status in [:active, :password_reset_pending] do
	:visible
	else
	status
	end
	end

	@spec privileged?(User.t(), atom()) :: boolean()
	def privileged?(%User{is_admin: false, is_moderator: false}, _), do: false

	def privileged?(
	%User{local: true, is_admin: is_admin, is_moderator: is_moderator},
	privilege_tag
	),
	do:
	privileged_for?(privilege_tag, is_admin, :admin_privileges) or
	privileged_for?(privilege_tag, is_moderator, :moderator_privileges)

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

	defp privileged_for?(privilege_tag, true, config_role_key),
	do: privilege_tag in Config.get([:instance, config_role_key])

	defp privileged_for?(_, _, _), do: false

	@spec privileges(User.t()) :: [atom()]
	def privileges(%User{local: false}) do
	[]
	end

	def privileges(%User{is_moderator: false, is_admin: false}) do
	[]
	end

	def privileges(%User{local: true, is_moderator: true, is_admin: true}) do
	(Config.get([:instance, :moderator_privileges]) ++ Config.get([:instance, :admin_privileges]))
	\|> Enum.uniq()
	end

	def privileges(%User{local: true, is_moderator: true, is_admin: false}) do
	Config.get([:instance, :moderator_privileges])
	end

	def privileges(%User{local: true, is_moderator: false, is_admin: true}) do
	Config.get([:instance, :admin_privileges])
	end

	@spec invisible?(User.t()) :: boolean()
	def invisible?(%User{invisible: true}), do: true
	def invisible?(_), do: false

	def avatar_url(user, options \\ []) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} ->
	href

	_ ->
	unless options[:no_default] do
	Config.get([:assets, :default_user_avatar], "#{Endpoint.url()}/images/avi.png")
	end
	end
	end

	def banner_url(user, options \\ []) do
	case user.banner do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> !options[:no_default] && "#{Endpoint.url()}/images/banner.png"
	end
	end

	# Should probably be renamed or removed
	@spec ap_id(User.t()) :: String.t()
	def ap_id(%User{nickname: nickname}), do: "#{Endpoint.url()}/users/#{nickname}"

	@spec ap_followers(User.t()) :: String.t()
	def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
	def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"

	@spec ap_following(User.t()) :: String.t()
	def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
	def ap_following(%User{} = user), do: "#{ap_id(user)}/following"

	@spec ap_featured_collection(User.t()) :: String.t()
	def ap_featured_collection(%User{featured_address: fa}) when is_binary(fa), do: fa

	def ap_featured_collection(%User{} = user), do: "#{ap_id(user)}/collections/featured"

	defp truncate_fields_param(params) do
	if Map.has_key?(params, :fields) do
	Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
	else
	params
	end
	end

	defp truncate_if_exists(params, key, max_length) do
	if Map.has_key?(params, key) and is_binary(params[key]) do
	{value, _chopped} = String.split_at(params[key], max_length)
	Map.put(params, key, value)
	else
	params
	end
	end

	defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params

	defp fix_follower_address(%{nickname: nickname} = params),
	do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))

	defp fix_follower_address(params), do: params

	def remote_user_changeset(struct \\ %User{local: false}, params) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)

	name =
	case params[:name] do
	name when is_binary(name) and byte_size(name) > 0 -> name
	_ -> params[:nickname]
	end

	params =
	params
	\|> Map.put(:name, name)
	\|> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
	\|> truncate_if_exists(:name, name_limit)
	\|> truncate_if_exists(:bio, bio_limit)
	\|> truncate_fields_param()
	\|> fix_follower_address()

	struct
	\|> cast(
	params,
	[
	:bio,
	:emoji,
	:ap_id,
	:inbox,
	:shared_inbox,
	:nickname,
	:public_key,
	:avatar,
	:banner,
	:is_locked,
	:last_refreshed_at,
	:uri,
	:follower_address,
	:following_address,
	:featured_address,
	:hide_followers,
	:hide_follows,
	:hide_followers_count,
	:hide_follows_count,
	:follower_count,
	:fields,
	:following_count,
	:is_discoverable,
	:invisible,
	:actor_type,
	:also_known_as,
	:accepts_chat_messages,
	:pinned_objects,
	:birthday,
	:show_birthday
	]
	)
	\|> cast(params, [:name], empty_values: [])
	\|> validate_required([:ap_id])
	\|> validate_required([:name], trim: false)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> validate_fields(true)
	\|> validate_non_local()
	end

	defp validate_non_local(cng) do
	local? = get_field(cng, :local)

	if local? do
	cng
	\|> add_error(:local, "User is local, can't update with this changeset.")
	else
	cng
	end
	end

	def update_changeset(struct, params \\ %{}) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)

	struct
	\|> cast(
	params,
	[
	:bio,
	:raw_bio,
	:name,
	:emoji,
	:avatar,
	:public_key,
	:inbox,
	:shared_inbox,
	:is_locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:hide_followers_count,
	:hide_follows_count,
	:hide_favorites,
	:allow_following_move,
	:also_known_as,
	:background,
	:show_role,
	:skip_thread_containment,
	:fields,
	:raw_fields,
	:pleroma_settings_store,
	:is_discoverable,
	:actor_type,
	:accepts_chat_messages,
	:disclose_client,
	:birthday,
	:show_birthday
	]
	)
	\|> validate_min_age()
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_inclusion(:actor_type, Pleroma.Constants.allowed_user_actor_types())
	\|> put_fields()
	\|> put_emoji()
	\|> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
	\|> put_change_if_present(:avatar, &put_upload(&1, :avatar))
	\|> put_change_if_present(:banner, &put_upload(&1, :banner))
	\|> put_change_if_present(:background, &put_upload(&1, :background))
	\|> put_change_if_present(
	:pleroma_settings_store,
	&{:ok, Map.merge(struct.pleroma_settings_store, &1)}
	)
	\|> validate_fields(false)
	end

	defp put_fields(changeset) do
	if raw_fields = get_change(changeset, :raw_fields) do
	raw_fields =
	raw_fields
	\|> Enum.filter(fn %{"name" => n} -> n != "" end)

	fields =
	raw_fields
	\|> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)

	changeset
	\|> put_change(:raw_fields, raw_fields)
	\|> put_change(:fields, fields)
	else
	changeset
	end
	end

	defp parse_fields(value) do
	value
	\|> Formatter.linkify(mentions_format: :full)
	\|> elem(0)
	end

	defp put_emoji(changeset) do
	emojified_fields = [:bio, :name, :raw_fields]

	if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
	bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
	name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))

	emoji = Map.merge(bio, name)

	emoji =
	changeset
	\|> get_field(:raw_fields)
	\|> Enum.reduce(emoji, fn x, acc ->
	Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
	end)

	put_change(changeset, :emoji, emoji)
	else
	changeset
	end
	end

	defp put_change_if_present(changeset, map_field, value_function) do
	with {:ok, value} <- fetch_change(changeset, map_field),
	{:ok, new_value} <- value_function.(value) do
	put_change(changeset, map_field, new_value)
	else
	{:error, :file_too_large} ->
	Ecto.Changeset.validate_change(changeset, map_field, fn map_field, _value ->
	[{map_field, "file is too large"}]
	end)

	_ ->
	changeset
	end
	end

	defp put_upload(value, type) do
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: type) do
	{:ok, object.data}
	end
	end

	def update_as_admin_changeset(struct, params) do
	struct
	\|> update_changeset(params)
	\|> cast(params, [:email])
	\|> delete_change(:also_known_as)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_inclusion(:actor_type, ["Person", "Service"])
	end

	@spec update_as_admin(User.t(), map()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def update_as_admin(user, params) do
	params = Map.put(params, "password_confirmation", params["password"])
	changeset = update_as_admin_changeset(user, params)

	if params["password"] do
	reset_password(user, changeset, params)
	else
	User.update_and_set_cache(changeset)
	end
	end

	def password_update_changeset(struct, params) do
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> put_password_hash()
	\|> put_change(:password_reset_pending, false)
	end

	@spec reset_password(User.t(), map()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def reset_password(%User{} = user, params) do
	reset_password(user, user, params)
	end

	def reset_password(%User{id: user_id} = user, struct, params) do
	multi =
	Multi.new()
	\|> Multi.update(:user, password_update_changeset(struct, params))
	\|> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
	\|> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))

	case Repo.transaction(multi) do
	{:ok, %{user: user} = _} -> set_cache(user)
	{:error, _, changeset, _} -> {:error, changeset}
	end
	end

	def update_password_reset_pending(user, value) do
	user
	\|> change()
	\|> put_change(:password_reset_pending, value)
	\|> update_and_set_cache()
	end

	def force_password_reset_async(user) do
	BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
	end

	@spec force_password_reset(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def force_password_reset(user), do: update_password_reset_pending(user, true)

	# Used to auto-register LDAP accounts which won't have a password hash stored locally
	def register_changeset_ldap(struct, params = %{password: password})
	when is_nil(password) do
	params = Map.put_new(params, :accepts_chat_messages, true)

	params =
	if Map.has_key?(params, :email) do
	Map.put_new(params, :email, params[:email])
	else
	params
	end

	struct
	\|> cast(params, [
	:name,
	:nickname,
	:email,
	:accepts_chat_messages
	])
	\|> validate_required([:name, :nickname])
	\|> unique_constraint(:nickname)
	\|> validate_not_restricted_nickname(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_and_featured_address()
	\|> put_private_key()
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)
	reason_limit = Config.get([:instance, :registration_reason_length], 500)
	params = Map.put_new(params, :accepts_chat_messages, true)

	confirmed? =
	if is_nil(opts[:confirmed]) do
	!Config.get([:instance, :account_activation_required])
	else
	opts[:confirmed]
	end

	approved? =
	if is_nil(opts[:approved]) do
	!Config.get([:instance, :account_approval_required])
	else
	opts[:approved]
	end

	struct
	\|> confirmation_changeset(set_confirmation: confirmed?)
	\|> approval_changeset(set_approval: approved?)
	\|> cast(params, [
	:bio,
	:raw_bio,
	:email,
	:name,
	:nickname,
	:password,
	:password_confirmation,
	:emoji,
	:accepts_chat_messages,
	:registration_reason,
	:birthday,
	:language
	])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_email_not_in_blacklisted_domain(:email)
	\|> unique_constraint(:nickname)
	\|> validate_not_restricted_nickname(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_length(:registration_reason, max: reason_limit)
	\|> maybe_validate_required_email(opts[:external])
	\|> maybe_validate_required_birthday
	\|> validate_min_age()
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_and_featured_address()
	\|> put_private_key()
	end

	def validate_not_restricted_nickname(changeset, field) do
	validate_change(changeset, field, fn _, value ->
	valid? =
	Config.get([User, :restricted_nicknames])
	\|> Enum.all?(fn restricted_nickname ->
	String.downcase(value) != String.downcase(restricted_nickname)
	end)

	if valid?, do: [], else: [nickname: "Invalid nickname"]
	end)
	end

	def validate_email_not_in_blacklisted_domain(changeset, field) do
	validate_change(changeset, field, fn _, value ->
	valid? =
	Config.get([User, :email_blacklist])
	\|> Enum.all?(fn blacklisted_domain ->
	blacklisted_domain_downcase = String.downcase(blacklisted_domain)

	!String.ends_with?(String.downcase(value), [
	"@" <> blacklisted_domain_downcase,
	"." <> blacklisted_domain_downcase
	])
	end)

	if valid?, do: [], else: [email: "Invalid email"]
	end)
	end

	def maybe_validate_required_email(changeset, true), do: changeset

	def maybe_validate_required_email(changeset, _) do
	if Config.get([:instance, :account_activation_required]) do
	validate_required(changeset, [:email])
	else
	changeset
	end
	end

	defp maybe_validate_required_birthday(changeset) do
	if Config.get([:instance, :birthday_required]) do
	validate_required(changeset, [:birthday])
	else
	changeset
	end
	end

	defp validate_min_age(changeset) do
	changeset
	\|> validate_change(:birthday, fn :birthday, birthday ->
	valid? =
	Date.utc_today()
	\|> Date.diff(birthday) >=
	Config.get([:instance, :birthday_min_age])

	if valid?, do: [], else: [birthday: "Invalid age"]
	end)
	end

	defp put_ap_id(changeset) do
	ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
	put_change(changeset, :ap_id, ap_id)
	end

	defp put_following_and_follower_and_featured_address(changeset) do
	user = %User{nickname: get_field(changeset, :nickname)}
	followers = ap_followers(user)
	following = ap_following(user)
	featured = ap_featured_collection(user)

	changeset
	\|> put_change(:follower_address, followers)
	\|> put_change(:following_address, following)
	\|> put_change(:featured_address, featured)
	end

	defp put_private_key(changeset) do
	{:ok, pem} = Keys.generate_rsa_pem()
	put_change(changeset, :keys, pem)
	end

	defp autofollow_users(user) do
	candidates = Config.get([:instance, :autofollowed_nicknames])

	autofollowed_users =
	User.Query.build(%{nickname: candidates, local: true, is_active: true})
	\|> Repo.all()

	follow_all(user, autofollowed_users)
	end

	defp autofollowing_users(user) do
	candidates = Config.get([:instance, :autofollowing_nicknames])

	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()
	\|> Enum.each(&follow(&1, user, :follow_accept))

	{:ok, :success}
	end

	@doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
	def register(%Ecto.Changeset{} = changeset) do
	with {:ok, user} <- Repo.insert(changeset) do
	post_register_action(user)
	end
	end

	def post_register_action(%User{is_confirmed: false} = user) do
	with {:ok, _} <- maybe_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{is_approved: false} = user) do
	with {:ok, _} <- send_user_approval_email(user),
	{:ok, _} <- send_admin_approval_emails(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
	with {:ok, user} <- autofollow_users(user),
	{:ok, _} <- autofollowing_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- maybe_send_registration_email(user),
	{:ok, _} <- maybe_send_welcome_email(user),
	{:ok, _} <- maybe_send_welcome_message(user),
	{:ok, _} <- maybe_send_welcome_chat_message(user) do
	{:ok, user}
	end
	end

	defp send_user_approval_email(%User{email: email} = user) when is_binary(email) do
	user
	\|> Pleroma.Emails.UserEmail.approval_pending_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	end

	defp send_user_approval_email(_user) do
	{:ok, :skipped}
	end

	defp send_admin_approval_emails(user) do
	all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, :enqueued}
	end

	defp maybe_send_welcome_message(user) do
	if User.WelcomeMessage.enabled?() do
	User.WelcomeMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_chat_message(user) do
	if User.WelcomeChatMessage.enabled?() do
	User.WelcomeChatMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
	if User.WelcomeEmail.enabled?() do
	User.WelcomeEmail.send_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_email(_), do: {:ok, :noop}

	@spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued \| :noop}
	def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
	when is_binary(email) do
	if Config.get([:instance, :account_activation_required]) do
	send_confirmation_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def maybe_send_confirmation_email(_), do: {:ok, :noop}

	@spec send_confirmation_email(User.t()) :: User.t()
	def send_confirmation_email(%User{} = user) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	user
	end

	@spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued \| :noop}
	defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
	with false <- User.WelcomeEmail.enabled?(),
	false <- Config.get([:instance, :account_activation_required], false),
	false <- Config.get([:instance, :account_approval_required], false) do
	user
	\|> Pleroma.Emails.UserEmail.successful_registration_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	else
	_ ->
	{:ok, :noop}
	end
	end

	defp maybe_send_registration_email(_), do: {:ok, :noop}

	def needs_update?(%User{local: true}), do: false

	def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true

	def needs_update?(%User{local: false} = user) do
	NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
	end

	def needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) ::
	{:ok, User.t(), User.t()} \| {:error, String.t()}

	# "Locked" (self-locked) users demand explicit authorization of follow requests
	def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
	follow(follower, followed, :follow_pending)
	end

	def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
	follow(follower, followed)
	end

	def maybe_direct_follow(%User{} = follower, %User{} = followed) do
	{:ok, follower, followed}
	end

	@doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
	@spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
	def follow_all(follower, followeds) do
	followeds
	\|> Enum.reject(fn followed -> blocks?(follower, followed) \|\| blocks?(followed, follower) end)
	\|> Enum.each(&follow(follower, &1, :follow_accept))

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	cond do
	not followed.is_active ->
	{:error, "Could not follow user: #{followed.nickname} is deactivated."}

	deny_follow_blocked and blocks?(followed, follower) ->
	{:error, "Could not follow user: #{followed.nickname} blocked you."}

	true ->
	FollowingRelationship.follow(follower, followed, state)
	end
	end

	def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
	{:error, "Not subscribed!"}
	end

	@spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} \| {:error, String.t()}
	def unfollow(%User{} = follower, %User{} = followed) do
	case do_unfollow(follower, followed) do
	{:ok, follower, followed} ->
	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}

	error ->
	error
	end
	end

	@spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} \| {:error, String.t()}
	defp do_unfollow(%User{} = follower, %User{} = followed) do
	case get_follow_state(follower, followed) do
	state when state in [:follow_pending, :follow_accept] ->
	FollowingRelationship.unfollow(follower, followed)

	nil ->
	{:error, "Not subscribed!"}
	end
	end

	@doc "Returns follow state as Pleroma.FollowingRelationship.State value"
	def get_follow_state(%User{} = follower, %User{} = following) do
	following_relationship = FollowingRelationship.get(follower, following)
	get_follow_state(follower, following, following_relationship)
	end

	def get_follow_state(
	%User{} = follower,
	%User{} = following,
	following_relationship
	) do
	case {following_relationship, following.local} do
	{nil, false} ->
	case Utils.fetch_latest_follow(follower, following) do
	%Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
	FollowingRelationship.state_to_enum(state)

	_ ->
	nil
	end

	{%{state: state}, _} ->
	state

	{nil, _} ->
	nil
	end
	end

	def locked?(%User{} = user) do
	user.is_locked \|\| false
	end

	def get_by_id(id) do
	Repo.get_by(User, id: id)
	end

	def get_by_ap_id(ap_id) do
	Repo.get_by(User, ap_id: ap_id)
	end

	def get_by_uri(uri) do
	Repo.get_by(User, uri: uri)
	end

	def get_all_by_ap_id(ap_ids) do
	from(u in __MODULE__,
	where: u.ap_id in ^ap_ids
	)
	\|> Repo.all()
	end

	def get_all_by_ids(ids) do
	from(u in __MODULE__, where: u.id in ^ids)
	\|> Repo.all()
	end

	# This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
	# of the ap_id and the domain and tries to get that user
	def get_by_guessed_nickname(ap_id) do
	domain = URI.parse(ap_id).host
	name = List.last(String.split(ap_id, "/"))
	nickname = "#{name}@#{domain}"

	get_cached_by_nickname(nickname)
	end

	def set_cache({:ok, user}), do: set_cache(user)
	def set_cache({:error, err}), do: {:error, err}

	def set_cache(%User{} = user) do
	@cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	@cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	@cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
	{:ok, user}
	end

	def update_and_set_cache(struct, params) do
	struct
	\|> update_changeset(params)
	\|> update_and_set_cache()
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	set_cache(user)
	end
	end

	def get_user_friends_ap_ids(user) do
	from(u in User.get_friends_query(user), select: u.ap_id)
	\|> Repo.all()
	end

	@spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
	def get_cached_user_friends_ap_ids(user) do
	@cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
	get_user_friends_ap_ids(user)
	end)
	end

	def invalidate_cache(user) do
	@cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	@cachex.del(:user_cache, "nickname:#{user.nickname}")
	@cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	@cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
	end

	@spec get_cached_by_ap_id(String.t()) :: User.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"

	with {:ok, nil} <- @cachex.get(:user_cache, key),
	user when not is_nil(user) <- get_by_ap_id(ap_id),
	{:ok, true} <- @cachex.put(:user_cache, key, user) do
	user
	else
	{:ok, user} -> user
	nil -> nil
	end
	end

	def get_cached_by_id(id) do
	key = "id:#{id}"

	ap_id =
	@cachex.fetch!(:user_cache, key, fn _ ->
	user = get_by_id(id)

	if user do
	@cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	{:commit, user.ap_id}
	else
	{:ignore, ""}
	end
	end)

	get_cached_by_ap_id(ap_id)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"

	@cachex.fetch!(:user_cache, key, fn _ ->
	case get_or_fetch_by_nickname(nickname) do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
	restrict_to_local = Config.get([:instance, :limit_to_local_content])

	cond do
	is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)

	restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
	get_cached_by_nickname(nickname_or_id)

	restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
	get_cached_by_nickname(nickname_or_id)

	true ->
	nil
	end
	end

	@spec get_by_nickname(String.t()) :: User.t() \| nil
	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname) \|\|
	if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
	Repo.get_by(User, nickname: local_nickname(nickname))
	end
	end

	def get_by_email(email), do: Repo.get_by(User, email: email)

	def get_by_nickname_or_email(nickname_or_email) do
	get_by_nickname(nickname_or_email) \|\| get_by_email(nickname_or_email)
	end

	def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	{:ok, user}
	else
	_e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- fetch_by_nickname(nickname) do
	{:ok, user}
	else
	_e -> {:error, "not found " <> nickname}
	end
	end
	end

	@spec get_followers_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_followers_query(%User{} = user, nil) do
	User.Query.build(%{followers: user, is_active: true})
	end

	def get_followers_query(%User{} = user, page) do
	user
	\|> get_followers_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_followers_query(User.t()) :: Ecto.Query.t()
	def get_followers_query(%User{} = user), do: get_followers_query(user, nil)

	@spec get_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> Repo.all()
	end

	@spec get_external_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_external_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> User.Query.build(%{external: true})
	\|> Repo.all()
	end

	def get_followers_ids(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	@spec get_friends_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_friends_query(%User{} = user, nil) do
	User.Query.build(%{friends: user, deactivated: false})
	end

	def get_friends_query(%User{} = user, page) do
	user
	\|> get_friends_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_friends_query(User.t()) :: Ecto.Query.t()
	def get_friends_query(%User{} = user), do: get_friends_query(user, nil)

	def get_friends(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

	def get_friends_ap_ids(%User{} = user) do
	user
	\|> get_friends_query(nil)
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end

	def get_friends_ids(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], inc: [note_count: 1])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def decrease_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	note_count: fragment("greatest(0, note_count - 1)")
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def update_note_count(%User{} = user, note_count \\ nil) do
	note_count =
	note_count \|\|
	from(
	a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)
	)
	\|> Repo.one()

	user
	\|> cast(%{note_count: note_count}, [:note_count])
	\|> update_and_set_cache()
	end

	@spec maybe_fetch_follow_information(User.t()) :: User.t()
	def maybe_fetch_follow_information(user) do
	with {:ok, user} <- fetch_follow_information(user) do
	user
	else
	e ->
	Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	user
	\|> follow_information_changeset(info)
	\|> update_and_set_cache()
	end
	end

	defp follow_information_changeset(user, params) do
	user
	\|> cast(params, [
	:hide_followers,
	:hide_follows,
	:follower_count,
	:following_count,
	:hide_followers_count,
	:hide_follows_count
	])
	end

	@spec update_follower_count(User.t()) :: {:ok, User.t()}
	def update_follower_count(%User{} = user) do
	if user.local or !Config.get([:instance, :external_user_synchronization]) do
	follower_count = FollowingRelationship.follower_count(user)

	user
	\|> follow_information_changeset(%{follower_count: follower_count})
	\|> update_and_set_cache
	else
	{:ok, maybe_fetch_follow_information(user)}
	end
	end

	@spec update_following_count(User.t()) :: {:ok, User.t()}
	def update_following_count(%User{local: false} = user) do
	if Config.get([:instance, :external_user_synchronization]) do
	{:ok, maybe_fetch_follow_information(user)}
	else
	{:ok, user}
	end
	end

	def update_following_count(%User{local: true} = user) do
	following_count = FollowingRelationship.following_count(user)

	user
	\|> follow_information_changeset(%{following_count: following_count})
	\|> update_and_set_cache()
	end

	@spec get_users_from_set([String.t()], keyword()) :: [User.t()]
	def get_users_from_set(ap_ids, opts \\ []) do
	local_only = Keyword.get(opts, :local_only, true)
	criteria = %{ap_id: ap_ids, is_active: true}
	criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria

	User.Query.build(criteria)
	\|> Repo.all()
	end

	@spec get_recipients_from_activity(Activity.t()) :: [User.t()]
	def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
	to = [actor \| to]

	query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})

	query
	\|> Repo.all()
	end

	@spec mute(User.t(), User.t(), map()) ::
	{:ok, list(UserRelationship.t())} \| {:error, String.t()}
	def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
	notifications? = Map.get(params, :notifications, true)
	duration = Map.get(params, :duration, 0)

	expires_at =
	if duration > 0 do
	DateTime.utc_now()
	\|> DateTime.add(duration)
	else
	nil
	end

	with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee, expires_at),
	{:ok, user_notification_mute} <-
	(notifications? &&
	UserRelationship.create_notification_mute(
	muter,
	mutee,
	expires_at
	)) \|\|
	{:ok, nil} do
	if duration > 0 do
	Pleroma.Workers.MuteExpireWorker.enqueue(
	"unmute_user",
	%{"muter_id" => muter.id, "mutee_id" => mutee.id},
	scheduled_at: expires_at
	)
	end

	@cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")

	{:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
	end
	end

	def unmute(%User{} = muter, %User{} = mutee) do
	with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
	{:ok, user_notification_mute} <-
	UserRelationship.delete_notification_mute(muter, mutee) do
	@cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
	{:ok, [user_mute, user_notification_mute]}
	end
	end

	def unmute(muter_id, mutee_id) do
	with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
	{:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
	unmute(muter, mutee)
	else
	{who, result} = error ->
	Logger.warning(
	"User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
	)

	{:error, error}
	end
	end

	def subscribe(%User{} = subscriber, %User{} = target) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	if blocks?(target, subscriber) and deny_follow_blocked do
	{:error, "Could not subscribe: #{target.nickname} is blocking you"}
	else
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.create_inverse_subscription(target, subscriber)
	end
	end

	def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
	with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
	subscribe(subscriber, subscribee)
	end
	end

	def unsubscribe(%User{} = unsubscriber, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.delete_inverse_subscription(target, unsubscriber)
	end

	def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unsubscribe(unsubscriber, user)
	end
	end

	def block(%User{} = blocker, %User{} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

	# clear any requested follows from both sides as well
	blocked =
	case CommonAPI.reject_follow_request(blocked, blocker) do
	{:ok, %User{} = updated_blocked} -> updated_blocked
	nil -> blocked
	end

	blocker =
	case CommonAPI.reject_follow_request(blocker, blocked) do
	{:ok, %User{} = updated_blocker} -> updated_blocker
	nil -> blocker
	end

	unsubscribe(blocked, blocker)

	unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
	if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)

	{:ok, blocker} = update_follower_count(blocker)
	{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
	add_to_block(blocker, blocked)
	end

	# helper to handle the block given only an actor's AP id
	def block(%User{} = blocker, %{ap_id: ap_id}) do
	block(blocker, get_cached_by_ap_id(ap_id))
	end

	def unblock(%User{} = blocker, %User{} = blocked) do
	remove_from_block(blocker, blocked)
	end

	# helper to handle the block given only an actor's AP id
	def unblock(%User{} = blocker, %{ap_id: ap_id}) do
	unblock(blocker, get_cached_by_ap_id(ap_id))
	end

	def endorse(%User{} = endorser, %User{} = target) do
	with max_endorsed_users <- Pleroma.Config.get([:instance, :max_endorsed_users], 0),
	endorsed_users <-
	User.endorsed_users_relation(endorser)
	\|> Repo.aggregate(:count, :id) do
	cond do
	endorsed_users >= max_endorsed_users ->
	{:error, "You have already pinned the maximum number of users"}

	not following?(endorser, target) ->
	{:error, "Could not endorse: You are not following #{target.nickname}"}

	true ->
	UserRelationship.create_endorsement(endorser, target)
	end
	end
	end

	def endorse(%User{} = endorser, %{ap_id: ap_id}) do
	with %User{} = endorsed <- get_cached_by_ap_id(ap_id) do
	endorse(endorser, endorsed)
	end
	end

	def unendorse(%User{} = unendorser, %User{} = target) do
	UserRelationship.delete_endorsement(unendorser, target)
	end

	def unendorse(%User{} = unendorser, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unendorse(unendorser, user)
	end
	end

	def mutes?(nil, _), do: false
	def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)

	def mutes_user?(%User{} = user, %User{} = target) do
	UserRelationship.mute_exists?(user, target)
	end

	@spec muted_notifications?(User.t() \| nil, User.t() \| map()) :: boolean()
	def muted_notifications?(nil, _), do: false

	def muted_notifications?(%User{} = user, %User{} = target),
	do: UserRelationship.notification_mute_exists?(user, target)

	def blocks?(nil, _), do: false

	def blocks?(%User{} = user, %User{} = target) do
	blocks_user?(user, target) \|\|
	(blocks_domain?(user, target) and not User.following?(user, target))
	end

	def blocks_user?(%User{} = user, %User{} = target) do
	UserRelationship.block_exists?(user, target)
	end

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

	def blocks_domain?(%User{} = user, %User{} = target) do
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
	%{host: host} = URI.parse(target.ap_id)
	Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
	end

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

	def subscribed_to?(%User{} = user, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.inverse_subscription_exists?(target, user)
	end

	def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
	with %User{} = target <- get_cached_by_ap_id(ap_id) do
	subscribed_to?(user, target)
	end
	end

	def endorses?(%User{} = user, %User{} = target) do
	UserRelationship.endorsement_exists?(user, target)
	end

	@doc """
	Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
	E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
	"""
	@spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
	def outgoing_relationships_ap_ids(_user, []), do: %{}

	def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}

	def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
	when is_list(relationship_types) do
	db_result =
	user
	\|> assoc(:outgoing_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :target))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
	\|> group_by([user_rel, u], user_rel.relationship_type)
	\|> Repo.all()
	\|> Enum.into(%{}, fn [k, v] -> {k, v} end)

	Enum.into(
	relationship_types,
	%{},
	fn rel_type -> {rel_type, db_result[rel_type] \|\| []} end
	)
	end

	def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)

	def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
	when is_list(relationship_types) do
	user
	\|> assoc(:incoming_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :source))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> maybe_filter_on_ap_id(ap_ids)
	\|> select([user_rel, u], u.ap_id)
	\|> distinct(true)
	\|> Repo.all()
	end

	defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
	where(query, [user_rel, u], u.ap_id in ^ap_ids)
	end

	defp maybe_filter_on_ap_id(query, _ap_ids), do: query

	def set_activation_async(user, status \\ true) do
	BackgroundWorker.enqueue("user_activation", %{"user_id" => user.id, "status" => status})
	end

	@spec set_activation([User.t()], boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_activation(users, status) when is_list(users) do
	Repo.transaction(fn ->
	- for user <- users, do: set_activation(user, status)
	+ for user <- users do
	+ {:ok, user} = set_activation(user, status)
	+ user
	+ end
	end)
	end

	@spec set_activation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_activation(%User{} = user, status) do
	with {:ok, user} <- set_activation_status(user, status) do
	user
	\|> get_followers()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&set_cache(update_following_count(&1)))

	# Only update local user counts, remote will be update during the next pull.
	user
	\|> get_friends()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&do_unfollow(user, &1))

	{:ok, user}
	end
	end

	def approve(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- approve(user), do: user
	end)
	end)
	end

	def approve(%User{is_approved: false} = user) do
	with chg <- change(user, is_approved: true),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def approve(%User{} = user), do: {:ok, user}

	def confirm(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- confirm(user), do: user
	end)
	end)
	end

	def confirm(%User{is_confirmed: false} = user) do
	with chg <- confirmation_changeset(user, set_confirmation: true),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def confirm(%User{} = user), do: {:ok, user}

	def set_suggestion(users, is_suggested) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- set_suggestion(user, is_suggested), do: user
	end)
	end)
	end

	def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}

	def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
	user
	\|> change(is_suggested: is_suggested)
	\|> update_and_set_cache()
	end

	def update_notification_settings(%User{} = user, settings) do
	user
	\|> cast(%{notification_settings: settings}, [])
	\|> cast_embed(:notification_settings)
	\|> validate_required([:notification_settings])
	\|> update_and_set_cache()
	end

	@spec purge_user_changeset(User.t()) :: Ecto.Changeset.t()
	def purge_user_changeset(user) do
	# "Right to be forgotten"
	# https://gdpr.eu/right-to-be-forgotten/
	change(user, %{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	avatar: %{},
	tags: [],
	last_refreshed_at: nil,
	last_digest_emailed_at: nil,
	banner: %{},
	background: %{},
	note_count: 0,
	follower_count: 0,
	following_count: 0,
	is_locked: false,
	password_reset_pending: false,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	is_active: false,
	is_moderator: false,
	is_admin: false,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	# id: preserved
	# ap_id: preserved
	# nickname: preserved
	})
	end

	# Purge doesn't delete the user from the database.
	# It just nulls all its fields and deactivates it.
	# See `User.purge_user_changeset/1` above.
	defp purge(%User{} = user) do
	user
	\|> purge_user_changeset()
	\|> update_and_set_cache()
	end

	def delete(users) when is_list(users) do
	for user <- users, do: delete(user)
	end

	def delete(%User{} = user) do
	# Purge the user immediately
	purge(user)
	BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
	end

	# Actually delete the user from the DB
	defp delete_from_db(%User{} = user) do
	invalidate_cache(user)
	Repo.delete(user)
	end

	# If the user never finalized their account, it's safe to delete them.
	defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
	do: delete_from_db(user)

	defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
	do: delete_from_db(user)

	defp maybe_delete_from_db(user), do: {:ok, user}

	def perform(:force_password_reset, user), do: force_password_reset(user)

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:delete, %User{} = user) do
	# Purge the user again, in case perform/2 is called directly
	purge(user)

	# Remove all relationships
	user
	\|> get_followers()
	\|> Enum.each(fn follower ->
	ActivityPub.unfollow(follower, user)
	unfollow(follower, user)
	end)

	user
	\|> get_friends()
	\|> Enum.each(fn followed ->
	ActivityPub.unfollow(user, followed)
	unfollow(user, followed)
	end)

	delete_user_activities(user)
	delete_notifications_from_user_activities(user)
	delete_outgoing_pending_follow_requests(user)

	maybe_delete_from_db(user)
	end

	def perform(:set_activation_async, user, status), do: set_activation(user, status)

	@spec external_users_query() :: Ecto.Query.t()
	def external_users_query do
	User.Query.build(%{
	external: true,
	active: true,
	order_by: :id
	})
	end

	@spec external_users(keyword()) :: [User.t()]
	def external_users(opts \\ []) do
	query =
	external_users_query()
	\|> select([u], struct(u, [:id, :ap_id]))

	query =
	if opts[:max_id],
	do: where(query, [u], u.id > ^opts[:max_id]),
	else: query

	query =
	if opts[:limit],
	do: limit(query, ^opts[:limit]),
	else: query

	Repo.all(query)
	end

	def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
	Notification
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> where([n, a], fragment("? = ?", a.actor, ^ap_id))
	\|> Repo.delete_all()
	end

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.chunk_stream(50, :batches)
	\|> Stream.each(fn activities ->
	Enum.each(activities, fn activity -> delete_activity(activity, user) end)
	end)
	\|> Stream.run()
	end

	defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
	with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
	{:ok, delete_data, _} <- Builder.delete(user, object) do
	Pipeline.common_pipeline(delete_data, local: user.local)
	else
	{:find_object, nil} ->
	# We have the create activity, but not the object, it was probably pruned.
	# Insert a tombstone and try again
	with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	delete_activity(activity, user)
	end

	e ->
	Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
	Logger.error("Error: #{inspect(e)}")
	end
	end

	defp delete_activity(%{data: %{"type" => type}} = activity, user)
	when type in ["Like", "Announce"] do
	{:ok, undo, _} = Builder.undo(user, activity)
	Pipeline.common_pipeline(undo, local: user.local)
	end

	defp delete_activity(_activity, _user), do: "Doing nothing"

	defp delete_outgoing_pending_follow_requests(user) do
	user
	\|> FollowingRelationship.outgoing_pending_follow_requests_query()
	\|> Repo.delete_all()
	end

	def html_filter_policy(%User{no_rich_text: true}) do
	Pleroma.HTML.Scrubber.TwitterText
	end

	def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])

	def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)

	def get_or_fetch_by_ap_id(ap_id) do
	cached_user = get_cached_by_ap_id(ap_id)

	maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)

	case {cached_user, maybe_fetched_user} do
	{_, {:ok, %User{} = user}} ->
	{:ok, user}

	{%User{} = user, _} ->
	{:ok, user}

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

	@doc """
	Creates an internal service actor by URI if missing.
	Optionally takes nickname for addressing.
	"""
	@spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() \| nil
	def get_or_create_service_actor_by_ap_id(uri, nickname) do
	{_, user} =
	case get_cached_by_ap_id(uri) do
	nil ->
	with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
	Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
	{:error, nil}
	end

	%User{invisible: false} = user ->
	set_invisible(user)

	user ->
	{:ok, user}
	end

	user
	end

	@spec set_invisible(User.t()) :: {:ok, User.t()}
	defp set_invisible(user) do
	user
	\|> change(%{invisible: true})
	\|> update_and_set_cache()
	end

	@spec create_service_actor(String.t(), String.t()) ::
	{:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	defp create_service_actor(uri, nickname) do
	%User{
	invisible: true,
	local: true,
	ap_id: uri,
	nickname: nickname,
	follower_address: uri <> "/followers"
	}
	\|> change
	\|> put_private_key()
	\|> unique_constraint(:nickname)
	\|> Repo.insert()
	\|> set_cache()
	end

	def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
	key =
	public_key_pem
	\|> :public_key.pem_decode()
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

	def public_key(_), do: {:error, "key not found"}

	def get_public_key_for_ap_id(ap_id) do
	with %User{} = user <- get_cached_by_ap_id(ap_id),
	{:ok, public_key} <- public_key(user) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def get_or_fetch("http://" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch("https://" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

	# wait a period of time and return newest version of the User structs
	# this is because we have synchronous follow APIs and need to simulate them
	# with an async handshake
	def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
	with %User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
	with :ok <- :timer.sleep(timeout),
	%User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def parse_bio(bio) when is_binary(bio) and bio != "" do
	bio
	\|> CommonUtils.format_input("text/plain", mentions_format: :full)
	\|> elem(0)
	end

	def parse_bio(_), do: ""

	def parse_bio(bio, user) when is_binary(bio) and bio != "" do
	# TODO: get profile URLs other than user.ap_id
	profile_urls = [user.ap_id]

	bio
	\|> CommonUtils.format_input("text/plain",
	mentions_format: :full,
	rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
	)
	\|> elem(0)
	end

	def parse_bio(_, _), do: ""

	def tag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
	end)
	end

	def tag(nickname, tags) when is_binary(nickname),
	do: tag(get_by_nickname(nickname), tags)

	def tag(%User{} = user, tags),
	do: update_tags(user, Enum.uniq((user.tags \|\| []) ++ normalize_tags(tags)))

	def untag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
	end)
	end

	def untag(nickname, tags) when is_binary(nickname),
	do: untag(get_by_nickname(nickname), tags)

	def untag(%User{} = user, tags),
	do: update_tags(user, (user.tags \|\| []) -- normalize_tags(tags))

	defp update_tags(%User{} = user, new_tags) do
	{:ok, updated_user} =
	user
	\|> change(%{tags: new_tags})
	\|> update_and_set_cache()

	updated_user
	end

	defp normalize_tags(tags) do
	[tags]
	\|> List.flatten()
	\|> Enum.map(&String.downcase/1)
	end

	defp local_nickname_regex do
	if Config.get([:instance, :extended_nickname_format]) do
	@extended_local_nickname_regex
	else
	@strict_local_nickname_regex
	end
	end

	def local_nickname(nickname_or_mention) do
	nickname_or_mention
	\|> full_nickname()
	\|> String.split("@")
	\|> hd()
	end

	def full_nickname(%User{} = user) do
	if String.contains?(user.nickname, "@") do
	user.nickname
	else
	host = Pleroma.Web.WebFinger.host()
	user.nickname <> "@" <> host
	end
	end

	def full_nickname(nickname_or_mention),
	do: String.trim_leading(nickname_or_mention, "@")

	def error_user(ap_id) do
	%User{
	name: ap_id,
	ap_id: ap_id,
	nickname: "erroruser@example.com",
	inserted_at: NaiveDateTime.utc_now()
	}
	end

	@spec all_superusers() :: [User.t()]
	def all_superusers do
	User.Query.build(%{super_users: true, local: true, is_active: true})
	\|> Repo.all()
	end

	@spec all_users_with_privilege(atom()) :: [User.t()]
	def all_users_with_privilege(privilege) do
	User.Query.build(%{is_privileged: privilege}) \|> Repo.all()
	end

	def muting_reblogs?(%User{} = user, %User{} = target) do
	UserRelationship.reblog_mute_exists?(user, target)
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	not muting_reblogs?(user, target)
	end

	@doc """
	The function returns a query to get users with no activity for given interval of days.
	Inactive users are those who didn't read any notification, or had any activity where
	the user is the activity's actor, during `inactivity_threshold` days.
	Deactivated users will not appear in this list.

	## Examples

	iex> Pleroma.User.list_inactive_users()
	%Ecto.Query{}
	"""
	@spec list_inactive_users_query(integer()) :: Ecto.Query.t()
	def list_inactive_users_query(inactivity_threshold \\ 7) do
	negative_inactivity_threshold = -inactivity_threshold
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	# Subqueries are not supported in `where` clauses, join gets too complicated.
	has_read_notifications =
	from(n in Pleroma.Notification,
	where: n.seen == true,
	group_by: n.id,
	having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
	select: n.user_id
	)
	\|> Pleroma.Repo.all()

	from(u in Pleroma.User,
	left_join: a in Pleroma.Activity,
	on: u.ap_id == a.actor,
	where: not is_nil(u.nickname),
	where: u.is_active == ^true,
	where: u.id not in ^has_read_notifications,
	group_by: u.id,
	having:
	max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
	is_nil(max(a.inserted_at))
	)
	end

	@doc """
	Enable or disable email notifications for user

	## Examples

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
	Pleroma.User{email_notifications: %{"digest" => true}}

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
	Pleroma.User{email_notifications: %{"digest" => false}}
	"""
	@spec switch_email_notifications(t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, Ecto.Changeset.t()}
	def switch_email_notifications(user, type, status) do
	User.update_email_notifications(user, %{type => status})
	end

	@doc """
	Set `last_digest_emailed_at` value for the user to current time
	"""
	@spec touch_last_digest_emailed_at(t()) :: t()
	def touch_last_digest_emailed_at(user) do
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	{:ok, updated_user} =
	user
	\|> change(%{last_digest_emailed_at: now})
	\|> update_and_set_cache()

	updated_user
	end

	@spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_confirmation(%User{} = user, bool) do
	user
	\|> confirmation_changeset(set_confirmation: bool)
	\|> update_and_set_cache()
	end

	def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
	mascot
	end

	def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
	# use instance-default
	config = Config.get([:assets, :mascots])
	default_mascot = Config.get([:assets, :default_mascot])
	mascot = Keyword.get(config, default_mascot)

	%{
	"id" => "default-mascot",
	"url" => mascot[:url],
	"preview_url" => mascot[:url],
	"pleroma" => %{
	"mime_type" => mascot[:mime_type]
	}
	}
	end

	def get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	order_by: fragment("array_position(?, ?)", ^nicknames, u.nickname),
	select: u.ap_id
	)
	\|> Repo.all()
	end

	defp put_password_hash(
	%Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
	) do
	change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
	end

	defp put_password_hash(changeset), do: changeset

	def is_internal_user?(%User{nickname: nil}), do: true
	def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
	def is_internal_user?(_), do: false

	# A hack because user delete activities have a fake id for whatever reason
	# TODO: Get rid of this
	def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []

	def get_delivered_users_by_object_id(object_id) do
	from(u in User,
	inner_join: delivery in assoc(u, :deliveries),
	where: delivery.object_id == ^object_id
	)
	\|> Repo.all()
	end

	def change_email(user, email) do
	user
	\|> cast(%{email: email}, [:email])
	\|> maybe_validate_required_email(false)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> update_and_set_cache()
	end

	def alias_users(user) do
	user.also_known_as
	\|> Enum.map(&User.get_cached_by_ap_id/1)
	\|> Enum.filter(fn user -> user != nil end)
	end

	def add_alias(user, new_alias_user) do
	current_aliases = user.also_known_as \|\| []
	new_alias_ap_id = new_alias_user.ap_id

	if new_alias_ap_id in current_aliases do
	{:ok, user}
	else
	user
	\|> cast(%{also_known_as: current_aliases ++ [new_alias_ap_id]}, [:also_known_as])
	\|> update_and_set_cache()
	end
	end

	def delete_alias(user, alias_user) do
	current_aliases = user.also_known_as \|\| []
	alias_ap_id = alias_user.ap_id

	if alias_ap_id in current_aliases do
	user
	\|> cast(%{also_known_as: current_aliases -- [alias_ap_id]}, [:also_known_as])
	\|> update_and_set_cache()
	else
	{:error, :no_such_alias}
	end
	end

	# Internal function; public one is `deactivate/2`
	defp set_activation_status(user, status) do
	user
	\|> cast(%{is_active: status}, [:is_active])
	\|> update_and_set_cache()
	end

	def update_banner(user, banner) do
	user
	\|> cast(%{banner: banner}, [:banner])
	\|> update_and_set_cache()
	end

	def update_background(user, background) do
	user
	\|> cast(%{background: background}, [:background])
	\|> update_and_set_cache()
	end

	def validate_fields(changeset, remote? \\ false) do
	limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
	limit = Config.get([:instance, limit_name], 0)

	changeset
	\|> validate_length(:fields, max: limit)
	\|> validate_change(:fields, fn :fields, fields ->
	if Enum.all?(fields, &valid_field?/1) do
	[]
	else
	[fields: "invalid"]
	end
	end)
	end

	defp valid_field?(%{"name" => name, "value" => value}) do
	name_limit = Config.get([:instance, :account_field_name_length], 255)
	value_limit = Config.get([:instance, :account_field_value_length], 255)

	is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
	String.length(value) <= value_limit
	end

	defp valid_field?(_), do: false

	defp truncate_field(%{"name" => name, "value" => value}) do
	{name, _chopped} =
	String.split_at(name, Config.get([:instance, :account_field_name_length], 255))

	{value, _chopped} =
	String.split_at(value, Config.get([:instance, :account_field_value_length], 255))

	%{"name" => name, "value" => value}
	end

	def admin_api_update(user, params) do
	user
	\|> cast(params, [
	:is_moderator,
	:is_admin,
	:show_role
	])
	\|> update_and_set_cache()
	end

	@doc "Signs user out of all applications"
	def global_sign_out(user) do
	OAuth.Authorization.delete_user_authorizations(user)
	OAuth.Token.delete_user_tokens(user)
	end

	def mascot_update(user, url) do
	user
	\|> cast(%{mascot: url}, [:mascot])
	\|> validate_required([:mascot])
	\|> update_and_set_cache()
	end

	@spec confirmation_changeset(User.t(), keyword()) :: Ecto.Changeset.t()
	def confirmation_changeset(user, set_confirmation: confirmed?) do
	params =
	if confirmed? do
	%{
	is_confirmed: true,
	confirmation_token: nil
	}
	else
	%{
	is_confirmed: false,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	}
	end

	cast(user, params, [:is_confirmed, :confirmation_token])
	end

	@spec approval_changeset(User.t(), keyword()) :: Ecto.Changeset.t()
	def approval_changeset(user, set_approval: approved?) do
	cast(user, %{is_approved: approved?}, [:is_approved])
	end

	@spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} \| {:error, term()}
	def add_pinned_object_id(%User{} = user, object_id) do
	if !user.pinned_objects[object_id] do
	params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}

	user
	\|> cast(params, [:pinned_objects])
	\|> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
	max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)

	if Enum.count(pinned_objects) <= max_pinned_statuses do
	[]
	else
	[pinned_objects: "You have already pinned the maximum number of statuses"]
	end
	end)
	else
	change(user)
	end
	\|> update_and_set_cache()
	end

	@spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} \| {:error, term()}
	def remove_pinned_object_id(%User{} = user, object_id) do
	user
	\|> cast(
	%{pinned_objects: Map.delete(user.pinned_objects, object_id)},
	[:pinned_objects]
	)
	\|> update_and_set_cache()
	end

	def update_email_notifications(user, settings) do
	email_notifications =
	user.email_notifications
	\|> Map.merge(settings)
	\|> Map.take(["digest"])

	params = %{email_notifications: email_notifications}
	fields = [:email_notifications]

	user
	\|> cast(params, fields)
	\|> validate_required(fields)
	\|> update_and_set_cache()
	end

	defp set_domain_blocks(user, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

	user
	\|> cast(params, [:domain_blocks])
	\|> validate_required([:domain_blocks])
	\|> update_and_set_cache()
	end

	def block_domain(user, domain_blocked) do
	set_domain_blocks(user, Enum.uniq([domain_blocked \| user.domain_blocks]))
	end

	def unblock_domain(user, domain_blocked) do
	set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:error, Ecto.Changeset.t()}
	defp add_to_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:ok, nil} \| {:error, Ecto.Changeset.t()}
	defp remove_from_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	def set_invisible(user, invisible) do
	params = %{invisible: invisible}

	user
	\|> cast(params, [:invisible])
	\|> validate_required([:invisible])
	\|> update_and_set_cache()
	end

	def sanitize_html(%User{} = user) do
	sanitize_html(user, nil)
	end

	# User data that mastodon isn't filtering (treated as plaintext):
	# - field name
	# - display name
	def sanitize_html(%User{} = user, filter) do
	fields =
	Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
	%{
	"name" => name,
	"value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
	}
	end)

	user
	\|> Map.put(:bio, HTML.filter_tags(user.bio, filter))
	\|> Map.put(:fields, fields)
	end

	def get_host(%User{ap_id: ap_id} = _user) do
	URI.parse(ap_id).host
	end

	def update_last_active_at(%__MODULE__{local: true} = user) do
	user
	\|> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
	\|> update_and_set_cache()
	end

	def update_last_active_at(user), do: user

	def active_user_count(days \\ 30) do
	active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)

	__MODULE__
	\|> where([u], u.last_active_at >= ^active_after)
	\|> where([u], u.local == true)
	\|> Repo.aggregate(:count)
	end

	def update_last_status_at(user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], set: [last_status_at: fragment("NOW()")])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def get_friends_birthdays_query(%User{} = user, day, month) do
	User.Query.build(%{
	friends: user,
	deactivated: false,
	birthday_day: day,
	birthday_month: month
	})
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index 5e0d1aa8e..b3043b93a 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,332 +1,335 @@
	# 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.ObjectValidator do
	@moduledoc """
	This module is responsible for validating an object (which can be an activity)
	and checking if it is both well formed and also compatible with our view of
	the system.
	"""

	@behaviour Pleroma.Web.ActivityPub.ObjectValidator.Validating

	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AcceptRejectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AddRemoveValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnswerValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AudioImageVideoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateGenericValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EventValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator

	@impl true
	def validate(object, meta)

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

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

	{:ok, block_activity, meta}
	end
	end

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

	meta =
	meta
	\|> Keyword.put(:object_data, undone_object.data)

	{:ok, object, meta}
	end
	end

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

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

	def validate(
	%{"type" => "Create", "object" => %{"type" => objtype} = object} = create_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Image Event Article Note Page] do
	with {:ok, object_data} <- cast_and_apply_and_stringify_with_history(object),
	meta = Keyword.put(meta, :object_data, object_data),
	{:ok, create_activity} <-
	create_activity
	\|> CreateGenericValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Event Question Audio Video Image Article Note Page] do
	validator =
	case type do
	"Event" -> EventValidator
	"Question" -> QuestionValidator
	"Audio" -> AudioImageVideoValidator
	"Video" -> AudioImageVideoValidator
	"Image" -> AudioImageVideoValidator
	"Article" -> ArticleNotePageValidator
	"Note" -> ArticleNotePageValidator
	"Page" -> ArticleNotePageValidator
	end

	with {:ok, object} <-
	do_separate_with_history(object, fn object ->
	with {:ok, object} <-
	object
	\|> validator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)

	# Insert copy of hashtags as strings for the non-hashtag table indexing
	tag = (object["tag"] \|\| []) ++ Object.hashtags(%Object{data: object})
	object = Map.put(object, "tag", tag)

	{:ok, object}
	end
	end) do
	{:ok, object, meta}
	end
	end

	def validate(
	%{"type" => "Update", "object" => %{"type" => objtype} = object} = update_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Event Article Note Page] do
	with {_, false} <- {:local, Access.get(meta, :local, false)},
	{_, {:ok, object_data, _}} <- {:object_validation, validate(object, meta)},
	meta = Keyword.put(meta, :object_data, object_data),
	{:ok, update_activity} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	update_activity = stringify_keys(update_activity)
	{:ok, update_activity, meta}
	else
	{:local, _} ->
	with {:ok, object} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end

	{:object_validation, e} ->
	e
	+
	+ {:error, %Ecto.Changeset{} = e} ->
	+ {:error, e}
	end
	end

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Accept Reject Follow Update Like EmojiReact Announce
	ChatMessage Answer] do
	validator =
	case type do
	"Accept" -> AcceptRejectValidator
	"Reject" -> AcceptRejectValidator
	"Follow" -> FollowValidator
	"Update" -> UpdateValidator
	"Like" -> LikeValidator
	"EmojiReact" -> EmojiReactValidator
	"Announce" -> AnnounceValidator
	"ChatMessage" -> ChatMessageValidator
	"Answer" -> AnswerValidator
	end

	with {:ok, object} <-
	object
	\|> validator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => type} = object, meta) when type in ~w(Add Remove) do
	with {:ok, object} <-
	object
	\|> AddRemoveValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(o, m), do: {:error, {:validator_not_set, {o, m}}}

	def cast_and_apply_and_stringify_with_history(object) do
	do_separate_with_history(object, fn object ->
	with {:ok, object_data} <- cast_and_apply(object),
	object_data <- object_data \|> stringify_keys() do
	{:ok, object_data}
	end
	end)
	end

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

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

	def cast_and_apply(%{"type" => "Answer"} = object) do
	AnswerValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => type} = object) when type in ~w[Audio Image Video] do
	AudioImageVideoValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Event"} = object) do
	EventValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => type} = object) when type in ~w[Article Note Page] do
	ArticleNotePageValidator.cast_and_apply(object)
	end

	def cast_and_apply(o), do: {:error, {:validator_not_set, o}}

	def stringify_keys(object) when is_struct(object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) when is_map(object) do
	object
	\|> Enum.filter(fn {_, v} -> v != nil end)
	\|> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
	end

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

	def stringify_keys(object), do: object

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

	def fetch_actor_and_object(object) do
	fetch_actor(object)
	Object.normalize(object["object"], fetch: true)
	:ok
	end

	defp for_each_history_item(
	%{"type" => "OrderedCollection", "orderedItems" => items} = history,
	object,
	fun
	) do
	processed_items =
	Enum.map(items, fn item ->
	with item <- Map.put(item, "id", object["id"]),
	{:ok, item} <- fun.(item) do
	item
	else
	_ -> nil
	end
	end)

	if Enum.all?(processed_items, &(not is_nil(&1))) do
	{:ok, Map.put(history, "orderedItems", processed_items)}
	else
	{:error, :invalid_history}
	end
	end

	defp for_each_history_item(nil, _object, _fun) do
	{:ok, nil}
	end

	defp for_each_history_item(_, _object, _fun) do
	{:error, :invalid_history}
	end

	# fun is (object -> {:ok, validated_object_with_string_keys})
	defp do_separate_with_history(object, fun) do
	with history <- object["formerRepresentations"],
	object <- Map.drop(object, ["formerRepresentations"]),
	{_, {:ok, object}} <- {:main_body, fun.(object)},
	{_, {:ok, history}} <- {:history_items, for_each_history_item(history, object, fun)} do
	object =
	if history do
	Map.put(object, "formerRepresentations", history)
	else
	object
	end

	{:ok, object}
	else
	{:main_body, e} -> e
	{:history_items, e} -> e
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/side_effects.ex b/lib/pleroma/web/activity_pub/side_effects.ex
	index 59b19180d..8d0ae6ef9 100644
	--- a/lib/pleroma/web/activity_pub/side_effects.ex
	+++ b/lib/pleroma/web/activity_pub/side_effects.ex
	@@ -1,616 +1,627 @@
	# 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.SideEffects do
	@moduledoc """
	This module looks at an inserted object and executes the side effects that it
	implies. For example, a `Like` activity will increase the like count on the
	liked object, a `Follow` activity will add the user to the follower
	collection, and so on.
	"""
	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer
	alias Pleroma.Workers.PollWorker

	require Pleroma.Constants
	require Logger

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)
	@logger Pleroma.Config.get([:side_effects, :logger], Logger)

	@behaviour Pleroma.Web.ActivityPub.SideEffects.Handling

	defp ap_streamer, do: Pleroma.Config.get([:side_effects, :ap_streamer], ActivityPub)

	@impl true
	def handle(object, meta \\ [])

	# Task this handles
	# - Follows
	# - Sends a notification
	@impl true
	def handle(
	%{
	data: %{
	"actor" => actor,
	"type" => "Accept",
	"object" => follow_activity_id
	}
	} = object,
	meta
	) do
	with %Activity{actor: follower_id} = follow_activity <-
	Activity.get_by_ap_id(follow_activity_id),
	%User{} = followed <- User.get_cached_by_ap_id(actor),
	%User{} = follower <- User.get_cached_by_ap_id(follower_id),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	{:ok, _follower, followed} <-
	FollowingRelationship.update(follower, followed, :follow_accept) do
	Notification.update_notification_type(followed, follow_activity)
	end

	{:ok, object, meta}
	end

	# Task this handles
	# - Rejects all existing follow activities for this person
	# - Updates the follow state
	# - Dismisses notification
	@impl true
	def handle(
	%{
	data: %{
	"actor" => actor,
	"type" => "Reject",
	"object" => follow_activity_id
	}
	} = object,
	meta
	) do
	with %Activity{actor: follower_id} = follow_activity <-
	Activity.get_by_ap_id(follow_activity_id),
	%User{} = followed <- User.get_cached_by_ap_id(actor),
	%User{} = follower <- User.get_cached_by_ap_id(follower_id),
	{:ok, _follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject") do
	FollowingRelationship.update(follower, followed, :follow_reject)
	Notification.dismiss(follow_activity)
	end

	{:ok, object, meta}
	end

	# Tasks this handle
	# - Follows if possible
	# - Sends a notification
	# - Generates accept or reject if appropriate
	@impl true
	def handle(
	%{
	data: %{
	"id" => follow_id,
	"type" => "Follow",
	"object" => followed_user,
	"actor" => following_user
	}
	} = object,
	meta
	) do
	with %User{} = follower <- User.get_cached_by_ap_id(following_user),
	%User{} = followed <- User.get_cached_by_ap_id(followed_user),
	{_, {:ok, _, _}, _, _} <-
	{:following, User.follow(follower, followed, :follow_pending), follower, followed} do
	if followed.local && !followed.is_locked do
	{:ok, accept_data, _} = Builder.accept(followed, object)
	{:ok, _activity, _} = Pipeline.common_pipeline(accept_data, local: true)
	end
	else
	{:following, {:error, _}, _follower, followed} ->
	{:ok, reject_data, _} = Builder.reject(followed, object)
	{:ok, _activity, _} = Pipeline.common_pipeline(reject_data, local: true)

	_ ->
	nil
	end

	{:ok, notifications} = Notification.create_notifications(object, do_send: false)

	meta =
	meta
	\|> add_notifications(notifications)

	updated_object = Activity.get_by_ap_id(follow_id)

	{:ok, updated_object, meta}
	end

	# Tasks this handles:
	# - Unfollow and block
	@impl true
	def handle(
	%{data: %{"type" => "Block", "object" => blocked_user, "actor" => blocking_user}} =
	object,
	meta
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocking_user),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked_user) do
	User.block(blocker, blocked)
	end

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Update the user
	# - Update a non-user object (Note, Question, etc.)
	#
	# For a local user, we also get a changeset with the full information, so we
	# can update non-federating, non-activitypub settings as well.
	@impl true
	def handle(%{data: %{"type" => "Update", "object" => updated_object}} = object, meta) do
	updated_object_id = updated_object["id"]

	with {_, true} <- {:has_id, is_binary(updated_object_id)},
	%{"type" => type} <- updated_object,
	{_, is_user} <- {:is_user, type in Pleroma.Constants.actor_types()} do
	if is_user do
	handle_update_user(object, meta)
	else
	handle_update_object(object, meta)
	end
	else
	_ ->
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add like to object
	# - Set up notification
	@impl true
	def handle(%{data: %{"type" => "Like"}} = object, meta) do
	liked_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_like_to_object(object, liked_object)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles
	# - Actually create object
	# - Rollback if we couldn't create it
	# - Increase the user note count
	# - Increase the reply count
	# - Increase replies count
	# - Set up ActivityExpiration
	# - Set up notifications
	# - Index incoming posts for search (if needed)
	@impl true
	def handle(%{data: %{"type" => "Create"}} = activity, meta) do
	with {:ok, object, meta} <- handle_object_creation(meta[:object_data], activity, meta),
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	{:ok, notifications} = Notification.create_notifications(activity, do_send: false)
	{:ok, _user} = ActivityPub.increase_note_count_if_public(user, object)
	{:ok, _user} = ActivityPub.update_last_status_at_if_public(user, object)

	if in_reply_to = object.data["type"] != "Answer" && object.data["inReplyTo"] do
	Object.increase_replies_count(in_reply_to)
	end

	if quote_url = object.data["quoteUrl"] do
	Object.increase_quotes_count(quote_url)
	end

	reply_depth = (meta[:depth] \|\| 0) + 1

	# FIXME: Force inReplyTo to replies
	if Pleroma.Web.Federator.allowed_thread_distance?(reply_depth) and
	object.data["replies"] != nil do
	for reply_id <- object.data["replies"] do
	Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
	"id" => reply_id,
	"depth" => reply_depth
	})
	end
	end

	ConcurrentLimiter.limit(Pleroma.Web.RichMedia.Helpers, fn ->
	Task.start(fn -> Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity) end)
	end)

	Pleroma.Search.add_to_index(Map.put(activity, :object, object))

	Utils.maybe_handle_group_posts(activity)

	meta =
	meta
	\|> add_notifications(notifications)

	ap_streamer().stream_out(activity)

	{:ok, activity, meta}
	else
	e -> Repo.rollback(e)
	end
	end

	# Tasks this handles:
	# - Add announce to object
	# - Set up notification
	# - Stream out the announce
	@impl true
	def handle(%{data: %{"type" => "Announce"}} = object, meta) do
	announced_object = Object.get_by_ap_id(object.data["object"])
	user = User.get_cached_by_ap_id(object.data["actor"])

	Utils.add_announce_to_object(object, announced_object)

	if !User.is_internal_user?(user) do
	Notification.create_notifications(object)

	ap_streamer().stream_out(object)
	end

	{:ok, object, meta}
	end

	@impl true
	def handle(%{data: %{"type" => "Undo", "object" => undone_object}} = object, meta) do
	with undone_object <- Activity.get_by_ap_id(undone_object),
	:ok <- handle_undoing(undone_object) do
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add reaction to object
	# - Set up notification
	@impl true
	def handle(%{data: %{"type" => "EmojiReact"}} = object, meta) do
	reacted_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_emoji_reaction_to_object(object, reacted_object)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Delete and unpins the create activity
	# - Replace object with Tombstone
	# - Reduce the user note count
	# - Reduce the reply count
	# - Stream out the activity
	# - Removes posts from search index (if needed)
	@impl true
	def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object, meta) do
	deleted_object =
	Object.normalize(deleted_object, fetch: false) \|\|
	User.get_cached_by_ap_id(deleted_object)

	result =
	case deleted_object do
	%Object{} ->
	- with {:ok, deleted_object, _activity} <- Object.delete(deleted_object),
	+ with {_, {:ok, deleted_object, _activity}} <- {:object, Object.delete(deleted_object)},
	{_, actor} when is_binary(actor) <- {:actor, deleted_object.data["actor"]},
	- %User{} = user <- User.get_cached_by_ap_id(actor) do
	+ {_, %User{} = user} <- {:user, User.get_cached_by_ap_id(actor)} do
	User.remove_pinned_object_id(user, deleted_object.data["id"])

	{:ok, user} = ActivityPub.decrease_note_count_if_public(user, deleted_object)

	if in_reply_to = deleted_object.data["inReplyTo"] do
	Object.decrease_replies_count(in_reply_to)
	end

	if quote_url = deleted_object.data["quoteUrl"] do
	Object.decrease_quotes_count(quote_url)
	end

	MessageReference.delete_for_object(deleted_object)

	ap_streamer().stream_out(object)
	ap_streamer().stream_out_participations(deleted_object, user)
	:ok
	else
	{:actor, _} ->
	@logger.error("The object doesn't have an actor: #{inspect(deleted_object)}")
	:no_object_actor
	+
	+ {:user, _} ->
	+ @logger.error(
	+ "The object's actor could not be resolved to a user: #{inspect(deleted_object)}"
	+ )
	+
	+ :no_object_user
	+
	+ {:object, _} ->
	+ @logger.error("The object could not be deleted: #{inspect(deleted_object)}")
	+ {:error, object}
	end

	%User{} ->
	with {:ok, _} <- User.delete(deleted_object) do
	:ok
	end
	end

	if result == :ok do
	# Only remove from index when deleting actual objects, not users or anything else
	with %Pleroma.Object{} <- deleted_object do
	Pleroma.Search.remove_from_index(deleted_object)
	end

	{:ok, object, meta}
	else
	{:error, result}
	end
	end

	# Tasks this handles:
	# - adds pin to user
	# - removes expiration job for pinned activity, if was set for expiration
	@impl true
	def handle(%{data: %{"type" => "Add"} = data} = object, meta) do
	with %User{} = user <- User.get_cached_by_ap_id(data["actor"]),
	{:ok, _user} <- User.add_pinned_object_id(user, data["object"]) do
	# if pinned activity was scheduled for deletion, we remove job
	if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(meta[:activity_id]) do
	Oban.cancel_job(expiration.id)
	end

	{:ok, object, meta}
	else
	nil ->
	{:error, :user_not_found}

	{:error, changeset} ->
	if changeset.errors[:pinned_objects] do
	{:error, :pinned_statuses_limit_reached}
	else
	changeset.errors
	end
	end
	end

	# Tasks this handles:
	# - removes pin from user
	# - removes corresponding Add activity
	# - if activity had expiration, recreates activity expiration job
	@impl true
	def handle(%{data: %{"type" => "Remove"} = data} = object, meta) do
	with %User{} = user <- User.get_cached_by_ap_id(data["actor"]),
	{:ok, _user} <- User.remove_pinned_object_id(user, data["object"]) do
	data["object"]
	\|> Activity.add_by_params_query(user.ap_id, user.featured_address)
	\|> Repo.delete_all()

	# if pinned activity was scheduled for deletion, we reschedule it for deletion
	if meta[:expires_at] do
	# MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
	{:ok, expires_at} =
	Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast(meta[:expires_at])

	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: meta[:activity_id],
	expires_at: expires_at
	})
	end

	{:ok, object, meta}
	else
	nil -> {:error, :user_not_found}
	error -> error
	end
	end

	# Nothing to do
	@impl true
	def handle(object, meta) do
	{:ok, object, meta}
	end

	defp handle_update_user(
	%{data: %{"type" => "Update", "object" => updated_object}} = object,
	meta
	) do
	if changeset = Keyword.get(meta, :user_update_changeset) do
	changeset
	\|> User.update_and_set_cache()
	else
	{:ok, new_user_data} = ActivityPub.user_data_from_user_object(updated_object)

	User.get_by_ap_id(updated_object["id"])
	\|> User.remote_user_changeset(new_user_data)
	\|> User.update_and_set_cache()
	end

	{:ok, object, meta}
	end

	defp handle_update_object(
	%{data: %{"type" => "Update", "object" => updated_object}} = object,
	meta
	) do
	orig_object_ap_id = updated_object["id"]
	orig_object = Object.get_by_ap_id(orig_object_ap_id)
	orig_object_data = orig_object.data

	updated_object =
	if meta[:local] do
	# If this is a local Update, we don't process it by transmogrifier,
	# so we use the embedded object as-is.
	updated_object
	else
	meta[:object_data]
	end

	if orig_object_data["type"] in Pleroma.Constants.updatable_object_types() do
	{:ok, _, updated} =
	Object.Updater.do_update_and_invalidate_cache(orig_object, updated_object)

	if updated do
	object
	\|> Activity.normalize()
	\|> ActivityPub.notify_and_stream()
	end
	end

	{:ok, object, meta}
	end

	def handle_object_creation(%{"type" => "ChatMessage"} = object, _activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	actor = User.get_cached_by_ap_id(object.data["actor"])
	recipient = User.get_cached_by_ap_id(hd(object.data["to"]))

	streamables =
	[[actor, recipient], [recipient, actor]]
	\|> Enum.uniq()
	\|> Enum.map(fn [user, other_user] ->
	if user.local do
	{:ok, chat} = Chat.bump_or_create(user.id, other_user.ap_id)
	{:ok, cm_ref} = MessageReference.create(chat, object, user.ap_id != actor.ap_id)

	@cachex.put(
	:chat_message_id_idempotency_key_cache,
	cm_ref.id,
	meta[:idempotency_key]
	)

	{
	["user", "user:pleroma_chat"],
	{user, %{cm_ref \| chat: chat, object: object}}
	}
	end
	end)
	\|> Enum.filter(& &1)

	meta =
	meta
	\|> add_streamables(streamables)

	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => "Question"} = object, activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	PollWorker.schedule_poll_end(activity)
	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => "Answer"} = object_map, _activity, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object_map, meta) do
	Object.increase_vote_count(
	object.data["inReplyTo"],
	object.data["name"],
	object.data["actor"]
	)

	{:ok, object, meta}
	end
	end

	def handle_object_creation(%{"type" => objtype} = object, _activity, meta)
	when objtype in ~w[Audio Video Image Event Article Note Page] do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	{:ok, object, meta}
	end
	end

	# Nothing to do
	def handle_object_creation(object, _activity, meta) do
	{:ok, object, meta}
	end

	defp undo_like(nil, object), do: delete_object(object)

	defp undo_like(%Object{} = liked_object, object) do
	with {:ok, _} <- Utils.remove_like_from_object(object, liked_object) do
	delete_object(object)
	end
	end

	def handle_undoing(%{data: %{"type" => "Like"}} = object) do
	object.data["object"]
	\|> Object.get_by_ap_id()
	\|> undo_like(object)
	end

	def handle_undoing(%{data: %{"type" => "EmojiReact"}} = object) do
	with %Object{} = reacted_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_emoji_reaction_from_object(object, reacted_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(%{data: %{"type" => "Announce"}} = object) do
	with %Object{} = liked_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_announce_from_object(object, liked_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(
	%{data: %{"type" => "Block", "actor" => blocker, "object" => blocked}} = object
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocker),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked),
	{:ok, _} <- User.unblock(blocker, blocked),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(object), do: {:error, ["don't know how to handle", object]}

	- @spec delete_object(Object.t()) :: :ok \| {:error, Ecto.Changeset.t()}
	+ @spec delete_object(Activity.t()) :: :ok \| {:error, Ecto.Changeset.t()}
	defp delete_object(object) do
	with {:ok, _} <- Repo.delete(object), do: :ok
	end

	defp send_notifications(meta) do
	Keyword.get(meta, :notifications, [])
	\|> Enum.each(fn notification ->
	Streamer.stream(["user", "user:notification"], notification)
	Push.send(notification)
	end)

	meta
	end

	defp send_streamables(meta) do
	Keyword.get(meta, :streamables, [])
	\|> Enum.each(fn {topics, items} ->
	Streamer.stream(topics, items)
	end)

	meta
	end

	defp add_streamables(meta, streamables) do
	existing = Keyword.get(meta, :streamables, [])

	meta
	\|> Keyword.put(:streamables, streamables ++ existing)
	end

	defp add_notifications(meta, notifications) do
	existing = Keyword.get(meta, :notifications, [])

	meta
	\|> Keyword.put(:notifications, notifications ++ existing)
	end

	@impl true
	def handle_after_transaction(meta) do
	meta
	\|> send_notifications()
	\|> send_streamables()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/side_effects/handling.ex b/lib/pleroma/web/activity_pub/side_effects/handling.ex
	index eb012f576..4751bb4ce 100644
	--- a/lib/pleroma/web/activity_pub/side_effects/handling.ex
	+++ b/lib/pleroma/web/activity_pub/side_effects/handling.ex
	@@ -1,8 +1,8 @@
	# 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.SideEffects.Handling do
	@callback handle(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	- @callback handle_after_transaction(map()) :: map()
	+ @callback handle_after_transaction(keyword()) :: keyword()
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index e2fc2640d..3413783e2 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,961 +1,960 @@
	# 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.Utils do
	alias Ecto.Changeset
	alias Ecto.UUID
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.EctoType.ActivityPub.ObjectValidators.ObjectID
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query

	require Logger
	require Pleroma.Constants

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

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

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

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

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

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

	def determine_explicit_mentions(_), do: []

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

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

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

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

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

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

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

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

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

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

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

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

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

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

	get_notified_from_object(fake_create_activity)
	end

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

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

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

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

	:ok
	end

	def maybe_federate(_), do: :ok

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

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

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

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

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

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

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

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

	defp lazy_put_object_defaults(activity, _), do: activity

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

	{:ok, map, object}
	end
	end

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

	#### Like-related helpers

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

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

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

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

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

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

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

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

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

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

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

	def add_emoji_reaction_to_object(
	%Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
	object
	) do
	reactions = get_cached_emoji_reactions(object)
	emoji = Pleroma.Emoji.maybe_strip_name(emoji)
	url = maybe_emoji_url(emoji, activity)

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

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

	count = emoji_count(new_reactions)

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

	defp maybe_emoji_url(
	name,
	%Activity{
	data: %{
	"tag" => [
	%{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}
	]
	}
	}
	),
	do: url

	defp maybe_emoji_url(_, _), do: nil

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

	def remove_emoji_reaction_from_object(
	%Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
	object
	) do
	emoji = Pleroma.Emoji.maybe_strip_name(emoji)
	reactions = get_cached_emoji_reactions(object)
	url = maybe_emoji_url(emoji, activity)

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

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

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

	def get_cached_emoji_reactions(object) do
	Object.get_emoji_reactions(object)
	end

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

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

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

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

	#### Follow-related helpers

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

	activity = Activity.get_by_id(activity.id)

	{:ok, activity}
	end

	def update_follow_state(
	%Activity{} = activity,
	state
	) do
	new_data = Map.put(activity.data, "state", state)
	changeset = Changeset.change(activity, data: new_data)

	with {:ok, activity} <- Repo.update(changeset) do
	{:ok, activity}
	end
	end

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

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

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

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

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

	defp custom_emoji_discriminator(query, emoji) do
	if String.contains?(emoji, "@") do
	stripped = Pleroma.Emoji.maybe_strip_name(emoji)
	[name, domain] = String.split(stripped, "@")
	domain_pattern = "%/" <> domain <> "/%"
	emoji_pattern = Pleroma.Emoji.maybe_quote(name)

	query
	\|> where([activity], fragment("?->>'content' = ?
	AND EXISTS (
	SELECT FROM jsonb_array_elements(?->'tag') elem
	WHERE elem->>'id' ILIKE ?
	)", activity.data, ^emoji_pattern, activity.data, ^domain_pattern))
	else
	query
	\|> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
	end
	end

	#### Announce-related helpers

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

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

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

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

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

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

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

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

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

	defp take_announcements(_), do: []

	#### Unfollow-related helpers

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

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

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

	#### Create-related helpers

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

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

	#### Listen-related helpers
	def make_listen_data(params, additional) do
	published = params.published \|\| make_date()

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

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

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

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

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

	defp build_flag_object(%Activity{} = activity) do
	object = Object.normalize(activity, fetch: false)

	# Do not allow people to report Creates. Instead, report the Object that is Created.
	if activity.data["type"] != "Create" do
	build_flag_object_with_actor_and_id(
	object,
	User.get_by_ap_id(activity.data["actor"]),
	activity.data["id"]
	)
	else
	build_flag_object(object)
	end
	end

	defp build_flag_object(%Object{} = object) do
	actor = User.get_by_ap_id(object.data["actor"])
	build_flag_object_with_actor_and_id(object, actor, object.data["id"])
	end

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

	case Activity.get_by_ap_id_with_object(id) do
	%Activity{object: object} = _ ->
	build_flag_object(object)

	nil ->
	- if %Object{} = object = Object.get_by_ap_id(id) do
	- build_flag_object(object)
	- else
	- %{"id" => id, "deleted" => true}
	+ case Object.get_by_ap_id(id) do
	+ %Object{} = object -> build_flag_object(object)
	+ _ -> %{"id" => id, "deleted" => true}
	end
	end
	end

	defp build_flag_object(_), do: []

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

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

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

	defp maybe_strip_report_status(data, state) do
	with true <- Config.get([:instance, :report_strip_status]),
	true <- state in @strip_status_report_states,
	{:ok, stripped_activity} = strip_report_status_data(%Activity{data: data}) do
	data \|> Map.put("object", stripped_activity.data["object"])
	else
	_ -> data
	end
	end

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

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

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

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

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

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

	stripped_activities =
	Enum.reduce(reported_activities, [], fn act, acc ->
	case ObjectID.cast(act) do
	{:ok, act} -> [act \| acc]
	_ -> acc
	end
	end)

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

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

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

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

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

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

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

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

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

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

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

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

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

	def get_existing_votes(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Create")
	\|> Activity.with_preloaded_object()
	\|> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
	\|> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
	\|> Repo.all()
	end

	def maybe_handle_group_posts(activity) do
	poster = User.get_cached_by_ap_id(activity.actor)

	mentions =
	activity.data["to"]
	\|> Enum.filter(&(&1 != activity.actor))

	mentioned_local_groups =
	User.get_all_by_ap_id(mentions)
	\|> Enum.filter(fn user ->
	user.actor_type == "Group" and
	user.local and
	not User.blocks?(user, poster)
	end)

	mentioned_local_groups
	\|> Enum.each(fn group ->
	Pleroma.Web.CommonAPI.repeat(activity.id, group)
	end)

	:ok
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/config_controller.ex b/lib/pleroma/web/admin_api/controllers/config_controller.ex
	index a03318c0e..989316041 100644
	--- a/lib/pleroma/web/admin_api/controllers/config_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/config_controller.ex
	@@ -1,198 +1,198 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ConfigController do
	use Pleroma.Web, :controller

	alias Pleroma.Config
	alias Pleroma.ConfigDB
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(OAuthScopesPlug, %{scopes: ["admin:write"]} when action == :update)

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:read"]}
	when action in [:show, :descriptions]
	)

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

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

	defp translate_descriptions(descriptions, path \\ []) do
	Enum.map(descriptions, fn desc -> translate_item(desc, path) end)
	end

	defp translate_string(str, path, type) do
	Gettext.dpgettext(
	Pleroma.Web.Gettext,
	"config_descriptions",
	Pleroma.Docs.Translator.Compiler.msgctxt_for(path, type),
	str
	)
	end

	defp maybe_put_translated(item, key, path) do
	if item[key] do
	Map.put(
	item,
	key,
	translate_string(
	item[key],
	path ++ [Pleroma.Docs.Translator.Compiler.key_for(item)],
	to_string(key)
	)
	)
	else
	item
	end
	end

	defp translate_item(item, path) do
	item
	\|> maybe_put_translated(:label, path)
	\|> maybe_put_translated(:description, path)
	\|> translate_children(path)
	end

	defp translate_children(%{children: children} = item, path) when is_list(children) do
	item
	\|> Map.put(
	:children,
	translate_descriptions(children, path ++ [Pleroma.Docs.Translator.Compiler.key_for(item)])
	)
	end

	defp translate_children(item, _path) do
	item
	end

	def descriptions(conn, _params) do
	descriptions = Enum.filter(Pleroma.Docs.JSON.compiled_descriptions(), &whitelisted_config?/1)

	json(conn, translate_descriptions(descriptions))
	end

	def show(conn, %{only_db: true}) do
	with :ok <- configurable_from_database() do
	configs = Pleroma.Repo.all(ConfigDB)

	render(conn, "index.json", %{
	configs: configs,
	need_reboot: Restarter.Pleroma.need_reboot?()
	})
	end
	end

	def show(conn, _params) do
	with :ok <- configurable_from_database() do
	configs = ConfigDB.get_all_as_keyword()

	merged =
	Config.Holder.default_config()
	\|> ConfigDB.merge(configs)
	\|> Enum.map(fn {group, values} ->
	Enum.map(values, fn {key, value} ->
	db =
	if configs[group][key] do
	ConfigDB.get_db_keys(configs[group][key], key)
	end

	db_value = configs[group][key]

	merged_value =
	if not is_nil(db_value) and Keyword.keyword?(db_value) and
	ConfigDB.sub_key_full_update?(group, key, Keyword.keys(db_value)) do
	ConfigDB.merge_group(group, key, value, db_value)
	else
	value
	end

	%ConfigDB{
	group: group,
	key: key,
	value: merged_value
	}
	\|> Pleroma.Maps.put_if_present(:db, db)
	end)
	end)
	\|> List.flatten()

	render(conn, "index.json", %{
	configs: merged,
	need_reboot: Restarter.Pleroma.need_reboot?()
	})
	end
	end

	- def update(%{body_params: %{configs: configs}} = conn, _) do
	+ def update(%{body_params: %{"configs" => configs}} = conn, _) do
	with :ok <- configurable_from_database() do
	results =
	configs
	\|> Enum.filter(&whitelisted_config?/1)
	\|> Enum.map(fn
	%{group: group, key: key, delete: true} = params ->
	ConfigDB.delete(%{group: group, key: key, subkeys: params[:subkeys]})

	%{group: group, key: key, value: value} ->
	ConfigDB.update_or_create(%{group: group, key: key, value: value})
	end)
	\|> Enum.reject(fn {result, _} -> result == :error end)

	{deleted, updated} =
	results
	\|> Enum.map(fn {:ok, %{key: key, value: value} = config} ->
	Map.put(config, :db, ConfigDB.get_db_keys(value, key))
	end)
	\|> Enum.split_with(&(Ecto.get_meta(&1, :state) == :deleted))

	Config.TransferTask.load_and_update_env(deleted, false)

	if not Restarter.Pleroma.need_reboot?() do
	changed_reboot_settings? =
	(updated ++ deleted)
	\|> Enum.any?(&Config.TransferTask.pleroma_need_restart?(&1.group, &1.key, &1.value))

	if changed_reboot_settings?, do: Restarter.Pleroma.need_reboot()
	end

	render(conn, "index.json", %{
	configs: updated,
	need_reboot: Restarter.Pleroma.need_reboot?()
	})
	end
	end

	defp configurable_from_database do
	if Config.get(:configurable_from_database) do
	:ok
	else
	{:error, "You must enable configurable_from_database in your config file."}
	end
	end

	defp whitelisted_config?(group, key) do
	if whitelisted_configs = Config.get(:database_config_whitelist) do
	Enum.any?(whitelisted_configs, fn
	{whitelisted_group} ->
	group == inspect(whitelisted_group)

	{whitelisted_group, whitelisted_key} ->
	group == inspect(whitelisted_group) && key == inspect(whitelisted_key)
	end)
	else
	true
	end
	end

	defp whitelisted_config?(%{group: group, key: key}) do
	whitelisted_config?(group, key)
	end

	defp whitelisted_config?(%{group: group} = config) do
	whitelisted_config?(group, config[:key])
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/instance_document_controller.ex b/lib/pleroma/web/admin_api/controllers/instance_document_controller.ex
	index 990a94313..a35878926 100644
	--- a/lib/pleroma/web/admin_api/controllers/instance_document_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/instance_document_controller.ex
	@@ -1,41 +1,41 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.InstanceDocumentController do
	use Pleroma.Web, :controller

	alias Pleroma.Web.InstanceDocument
	alias Pleroma.Web.Plugs.InstanceStatic
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

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

	plug(OAuthScopesPlug, %{scopes: ["admin:read"]} when action == :show)
	plug(OAuthScopesPlug, %{scopes: ["admin:write"]} when action in [:update, :delete])

	def show(conn, %{name: document_name}) do
	with {:ok, url} <- InstanceDocument.get(document_name),
	{:ok, content} <- File.read(InstanceStatic.file_path(url)) do
	conn
	\|> put_resp_content_type("text/html")
	\|> send_resp(200, content)
	end
	end

	- def update(%{body_params: %{file: file}} = conn, %{name: document_name}) do
	+ def update(%{body_params: %{"file" => file}} = conn, %{name: document_name}) do
	with {:ok, url} <- InstanceDocument.put(document_name, file.path) do
	json(conn, %{"url" => url})
	end
	end

	def delete(conn, %{name: document_name}) do
	with :ok <- InstanceDocument.delete(document_name) do
	json(conn, %{})
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/invite_controller.ex b/lib/pleroma/web/admin_api/controllers/invite_controller.ex
	index c5d759bb5..229b39909 100644
	--- a/lib/pleroma/web/admin_api/controllers/invite_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/invite_controller.ex
	@@ -1,78 +1,78 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.InviteController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper, only: [json_response: 3]

	alias Pleroma.Config
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	require Logger

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(OAuthScopesPlug, %{scopes: ["admin:read:invites"]} when action == :index)

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:write:invites"]} when action in [:create, :revoke, :email]
	)

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

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

	@doc "Get list of created invites"
	def index(conn, _params) do
	invites = UserInviteToken.list_invites()

	render(conn, "index.json", invites: invites)
	end

	@doc "Create an account registration invite token"
	def create(%{body_params: params} = conn, _) do
	{:ok, invite} = UserInviteToken.create_invite(params)

	render(conn, "show.json", invite: invite)
	end

	@doc "Revokes invite by token"
	- def revoke(%{body_params: %{token: token}} = conn, _) do
	+ def revoke(%{body_params: %{"token" => token}} = conn, _) do
	with {:ok, invite} <- UserInviteToken.find_by_token(token),
	{:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true}) do
	render(conn, "show.json", invite: updated_invite)
	else
	nil -> {:error, :not_found}
	error -> error
	end
	end

	@doc "Sends registration invite via email"
	- def email(%{assigns: %{user: user}, body_params: %{email: email} = params} = conn, _) do
	+ def email(%{assigns: %{user: user}, body_params: %{"email" => email} = params} = conn, _) do
	with {_, false} <- {:registrations_open, Config.get([:instance, :registrations_open])},
	{_, true} <- {:invites_enabled, Config.get([:instance, :invites_enabled])},
	{:ok, invite_token} <- UserInviteToken.create_invite(),
	{:ok, _} <-
	user
	\|> Pleroma.Emails.UserEmail.user_invitation_email(
	invite_token,
	email,
	- params[:name]
	+ params["name"]
	)
	\|> Pleroma.Emails.Mailer.deliver() do
	json_response(conn, :no_content, "")
	else
	{:registrations_open, _} ->
	{:error, "To send invites you need to set the `registrations_open` option to false."}

	{:invites_enabled, _} ->
	{:error, "To send invites you need to set the `invites_enabled` option to true."}

	{:error, error} ->
	{:error, error}
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/media_proxy_cache_controller.ex b/lib/pleroma/web/admin_api/controllers/media_proxy_cache_controller.ex
	index 4d53f5451..c615422cd 100644
	--- a/lib/pleroma/web/admin_api/controllers/media_proxy_cache_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/media_proxy_cache_controller.ex
	@@ -1,76 +1,76 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.MediaProxyCacheController do
	use Pleroma.Web, :controller

	alias Pleroma.Web.ApiSpec.Admin, as: Spec
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:read:media_proxy_caches"]} when action in [:index]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:write:media_proxy_caches"]} when action in [:purge, :delete]
	)

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

	defdelegate open_api_operation(action), to: Spec.MediaProxyCacheOperation

	def index(%{assigns: %{user: _}} = conn, params) do
	entries = fetch_entries(params)
	urls = paginate_entries(entries, params.page, params.page_size)

	render(conn, "index.json",
	urls: urls,
	page_size: params.page_size,
	count: length(entries)
	)
	end

	defp fetch_entries(params) do
	MediaProxy.cache_table()
	\|> @cachex.stream!(Cachex.Query.create(true, :key))
	\|> filter_entries(params[:query])
	end

	defp filter_entries(stream, query) when is_binary(query) do
	regex = ~r/#{query}/i

	stream
	\|> Enum.filter(fn url -> String.match?(url, regex) end)
	\|> Enum.to_list()
	end

	defp filter_entries(stream, _), do: Enum.to_list(stream)

	defp paginate_entries(entries, page, page_size) do
	offset = page_size * (page - 1)
	Enum.slice(entries, offset, page_size)
	end

	- def delete(%{assigns: %{user: _}, body_params: %{urls: urls}} = conn, _) do
	+ def delete(%{assigns: %{user: _}, body_params: %{"urls" => urls}} = conn, _) do
	MediaProxy.remove_from_banned_urls(urls)
	json(conn, %{})
	end

	- def purge(%{assigns: %{user: _}, body_params: %{urls: urls, ban: ban}} = conn, _) do
	+ def purge(%{assigns: %{user: _}, body_params: %{"urls" => urls, "ban" => ban}} = conn, _) do
	MediaProxy.Invalidation.purge(urls)

	if ban do
	MediaProxy.put_in_banned_urls(urls)
	end

	json(conn, %{})
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/relay_controller.ex b/lib/pleroma/web/admin_api/controllers/relay_controller.ex
	index 2e83fe139..664011b06 100644
	--- a/lib/pleroma/web/admin_api/controllers/relay_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/relay_controller.ex
	@@ -1,59 +1,62 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.RelayController do
	use Pleroma.Web, :controller

	alias Pleroma.ModerationLog
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	require Logger

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:write:follows"]}
	when action in [:follow, :unfollow]
	)

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

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

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

	def index(conn, _params) do
	with {:ok, list} <- Relay.list() do
	json(conn, %{relays: list})
	end
	end

	- def follow(%{assigns: %{user: admin}, body_params: %{relay_url: target}} = conn, _) do
	+ def follow(%{assigns: %{user: admin}, body_params: %{"relay_url" => target}} = conn, _) do
	with {:ok, _message} <- Relay.follow(target) do
	ModerationLog.insert_log(%{action: "relay_follow", actor: admin, target: target})

	json(conn, %{actor: target, followed_back: target in Relay.following()})
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	- def unfollow(%{assigns: %{user: admin}, body_params: %{relay_url: target} = params} = conn, _) do
	- with {:ok, _message} <- Relay.unfollow(target, %{force: params[:force]}) do
	+ def unfollow(
	+ %{assigns: %{user: admin}, body_params: %{"relay_url" => target} = params} = conn,
	+ _
	+ ) do
	+ with {:ok, _message} <- Relay.unfollow(target, %{force: params["force"]}) do
	ModerationLog.insert_log(%{action: "relay_unfollow", actor: admin, target: target})

	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/report_controller.ex b/lib/pleroma/web/admin_api/controllers/report_controller.ex
	index 15cbbcc3e..f667e7003 100644
	--- a/lib/pleroma/web/admin_api/controllers/report_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/report_controller.ex
	@@ -1,114 +1,114 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ReportController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper, only: [json_response: 3]

	alias Pleroma.Activity
	alias Pleroma.ModerationLog
	alias Pleroma.ReportNote
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI
	alias Pleroma.Web.AdminAPI.Report
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	require Logger

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(OAuthScopesPlug, %{scopes: ["admin:read:reports"]} when action in [:index, :show])

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:write:reports"]}
	when action in [:update, :notes_create, :notes_delete]
	)

	action_fallback(AdminAPI.FallbackController)

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

	def index(conn, params) do
	reports = Utils.get_reports(params, params.page, params.page_size)

	render(conn, "index.json", reports: reports)
	end

	def show(conn, %{id: id}) do
	with %Activity{} = report <- Activity.get_report(id) do
	render(conn, "show.json", Report.extract_report_info(report))
	else
	_ -> {:error, :not_found}
	end
	end

	- def update(%{assigns: %{user: admin}, body_params: %{reports: reports}} = conn, _) do
	+ def update(%{assigns: %{user: admin}, body_params: %{"reports" => reports}} = conn, _) do
	result =
	Enum.map(reports, fn report ->
	case CommonAPI.update_report_state(report.id, report.state) do
	{:ok, activity} ->
	report = Activity.get_by_id_with_user_actor(activity.id)

	ModerationLog.insert_log(%{
	action: "report_update",
	actor: admin,
	subject: activity,
	subject_actor: report.user_actor
	})

	activity

	{:error, message} ->
	%{id: report.id, error: message}
	end
	end)

	if Enum.any?(result, &Map.has_key?(&1, :error)) do
	json_response(conn, :bad_request, result)
	else
	json_response(conn, :no_content, "")
	end
	end

	- def notes_create(%{assigns: %{user: user}, body_params: %{content: content}} = conn, %{
	+ def notes_create(%{assigns: %{user: user}, body_params: %{"content" => content}} = conn, %{
	id: report_id
	}) do
	with {:ok, _} <- ReportNote.create(user.id, report_id, content),
	report <- Activity.get_by_id_with_user_actor(report_id) do
	ModerationLog.insert_log(%{
	action: "report_note",
	actor: user,
	subject: report,
	subject_actor: report.user_actor,
	text: content
	})

	json_response(conn, :no_content, "")
	else
	_ -> json_response(conn, :bad_request, "")
	end
	end

	def notes_delete(%{assigns: %{user: user}} = conn, %{
	id: note_id,
	report_id: report_id
	}) do
	with {:ok, note} <- ReportNote.destroy(note_id),
	report <- Activity.get_by_id_with_user_actor(report_id) do
	ModerationLog.insert_log(%{
	action: "report_note_delete",
	actor: user,
	subject: report,
	subject_actor: report.user_actor,
	text: note.content
	})

	json_response(conn, :no_content, "")
	else
	_ -> json_response(conn, :bad_request, "")
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/user_controller.ex b/lib/pleroma/web/admin_api/controllers/user_controller.ex
	index 7b4ee46a4..cca7d8c2f 100644
	--- a/lib/pleroma/web/admin_api/controllers/user_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/user_controller.ex
	@@ -1,309 +1,309 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.UserController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [fetch_integer_param: 3]

	alias Pleroma.ModerationLog
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.AdminAPI
	alias Pleroma.Web.AdminAPI.Search
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	@users_page_size 50

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

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

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:write:accounts"]}
	when action in [
	:delete,
	:create,
	:toggle_activation,
	:activate,
	:deactivate,
	:approve,
	:suggest,
	:unsuggest
	]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["admin:write:follows"]}
	when action in [:follow, :unfollow]
	)

	action_fallback(AdminAPI.FallbackController)

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

	def delete(conn, %{nickname: nickname}) do
	conn
	- \|> Map.put(:body_params, %{nicknames: [nickname]})
	+ \|> Map.put(:body_params, %{"nicknames" => [nickname]})
	\|> delete(%{})
	end

	- def delete(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def delete(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)

	Enum.each(users, fn user ->
	{:ok, delete_data, _} = Builder.delete(admin, user.ap_id)
	Pipeline.common_pipeline(delete_data, local: true)
	end)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "delete"
	})

	json(conn, nicknames)
	end

	def follow(
	%{
	assigns: %{user: admin},
	body_params: %{
	- follower: follower_nick,
	- followed: followed_nick
	+ "follower" => follower_nick,
	+ "followed" => followed_nick
	}
	} = conn,
	_
	) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.follow(follower, followed)

	ModerationLog.insert_log(%{
	actor: admin,
	followed: followed,
	follower: follower,
	action: "follow"
	})
	end

	json(conn, "ok")
	end

	def unfollow(
	%{
	assigns: %{user: admin},
	body_params: %{
	- follower: follower_nick,
	- followed: followed_nick
	+ "follower" => follower_nick,
	+ "followed" => followed_nick
	}
	} = conn,
	_
	) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.unfollow(follower, followed)

	ModerationLog.insert_log(%{
	actor: admin,
	followed: followed,
	follower: follower,
	action: "unfollow"
	})
	end

	json(conn, "ok")
	end

	- def create(%{assigns: %{user: admin}, body_params: %{users: users}} = conn, _) do
	+ def create(%{assigns: %{user: admin}, body_params: %{"users" => users}} = conn, _) do
	changesets =
	users
	\|> Enum.map(fn %{nickname: nickname, email: email, password: password} ->
	user_data = %{
	nickname: nickname,
	name: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	bio: "."
	}

	User.register_changeset(%User{}, user_data, need_confirmation: false)
	end)
	\|> Enum.reduce(Ecto.Multi.new(), fn changeset, multi ->
	Ecto.Multi.insert(multi, Ecto.UUID.generate(), changeset)
	end)

	case Pleroma.Repo.transaction(changesets) do
	{:ok, users_map} ->
	users =
	users_map
	\|> Map.values()
	\|> Enum.map(fn user ->
	{:ok, user} = User.post_register_action(user)

	user
	end)

	ModerationLog.insert_log(%{
	actor: admin,
	subjects: users,
	action: "create"
	})

	render(conn, "created_many.json", users: users)

	{:error, id, changeset, _} ->
	changesets =
	Enum.map(changesets.operations, fn
	{^id, {:changeset, _current_changeset, _}} ->
	changeset

	{_, {:changeset, current_changeset, _}} ->
	current_changeset
	end)

	conn
	\|> put_status(:conflict)
	\|> render("create_errors.json", changesets: changesets)
	end
	end

	def show(%{assigns: %{user: admin}} = conn, %{nickname: nickname}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname, for: admin) do
	render(conn, "show.json", %{user: user})
	else
	_ -> {:error, :not_found}
	end
	end

	def toggle_activation(%{assigns: %{user: admin}} = conn, %{nickname: nickname}) do
	user = User.get_cached_by_nickname(nickname)

	{:ok, updated_user} = User.set_activation(user, !user.is_active)

	action = if !user.is_active, do: "activate", else: "deactivate"

	ModerationLog.insert_log(%{
	actor: admin,
	subject: [user],
	action: action
	})

	render(conn, "show.json", user: updated_user)
	end

	- def activate(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def activate(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.set_activation(users, true)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "activate"
	})

	- render(conn, "index.json", users: Keyword.values(updated_users))
	+ render(conn, "index.json", users: updated_users)
	end

	- def deactivate(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def deactivate(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.set_activation(users, false)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "deactivate"
	})

	- render(conn, "index.json", users: Keyword.values(updated_users))
	+ render(conn, "index.json", users: updated_users)
	end

	- def approve(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def approve(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.approve(users)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "approve"
	})

	render(conn, "index.json", users: updated_users)
	end

	- def suggest(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def suggest(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.set_suggestion(users, true)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "add_suggestion"
	})

	render(conn, "index.json", users: updated_users)
	end

	- def unsuggest(%{assigns: %{user: admin}, body_params: %{nicknames: nicknames}} = conn, _) do
	+ def unsuggest(%{assigns: %{user: admin}, body_params: %{"nicknames" => nicknames}} = conn, _) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.set_suggestion(users, false)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "remove_suggestion"
	})

	render(conn, "index.json", users: updated_users)
	end

	def index(conn, params) do
	{page, page_size} = page_params(params)
	filters = maybe_parse_filters(params[:filters])

	search_params =
	%{
	query: params[:query],
	page: page,
	page_size: page_size,
	tags: params[:tags],
	name: params[:name],
	email: params[:email],
	actor_types: params[:actor_types]
	}
	\|> Map.merge(filters)

	with {:ok, users, count} <- Search.user(search_params) do
	render(conn, "index.json", users: users, count: count, page_size: page_size)
	end
	end

	@filters ~w(local external active deactivated need_approval unconfirmed is_admin is_moderator)

	@spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} \| %{}
	defp maybe_parse_filters(filters) when is_nil(filters) or filters == "", do: %{}

	defp maybe_parse_filters(filters) do
	filters
	\|> String.split(",")
	\|> Enum.filter(&Enum.member?(@filters, &1))
	\|> Map.new(&{String.to_existing_atom(&1), true})
	end

	defp page_params(params) do
	{
	fetch_integer_param(params, :page, 1),
	fetch_integer_param(params, :page_size, @users_page_size)
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/account_operation.ex b/lib/pleroma/web/api_spec/operations/account_operation.ex
	index 75cea2184..5d8d16e98 100644
	--- a/lib/pleroma/web/api_spec/operations/account_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/account_operation.ex
	@@ -1,976 +1,976 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.AccountOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Reference
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.AccountRelationship
	alias Pleroma.Web.ApiSpec.Schemas.ActorType
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	alias Pleroma.Web.ApiSpec.Schemas.List
	alias Pleroma.Web.ApiSpec.Schemas.Status
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	import Pleroma.Web.ApiSpec.Helpers

	@spec open_api_operation(atom) :: Operation.t()
	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	@spec create_operation() :: Operation.t()
	def create_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Register an account",
	description:
	"Creates a user and account records. Returns an account access token for the app that initiated the request. The app should save this token for later, and should wait for the user to confirm their account by clicking a link in their email inbox.",
	operationId: "AccountController.create",
	requestBody: request_body("Parameters", create_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", create_response()),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError),
	429 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def verify_credentials_operation do
	%Operation{
	tags: ["Account credentials"],
	description: "Test to make sure that the user token works.",
	summary: "Verify account credentials",
	operationId: "AccountController.verify_credentials",
	security: [%{"oAuth" => ["read:accounts"]}],
	responses: %{
	200 => Operation.response("Account", "application/json", Account)
	}
	}
	end

	def update_credentials_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Update account credentials",
	description: "Update the user's display and preferences.",
	operationId: "AccountController.update_credentials",
	security: [%{"oAuth" => ["write:accounts"]}],
	requestBody: request_body("Parameters", update_credentials_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", Account),
	403 => Operation.response("Error", "application/json", ApiError),
	413 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def relationships_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Relationship with current account",
	operationId: "AccountController.relationships",
	description: "Find out whether a given account is followed, blocked, muted, etc.",
	security: [%{"oAuth" => ["read:follows"]}],
	parameters: [
	Operation.parameter(
	:id,
	:query,
	%Schema{
	oneOf: [%Schema{type: :array, items: %Schema{type: :string}}, %Schema{type: :string}]
	},
	"Account IDs",
	example: "123"
	)
	],
	responses: %{
	200 => Operation.response("Account", "application/json", array_of_relationships())
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Account",
	operationId: "AccountController.show",
	description: "View information about a profile.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	with_relationships_param()
	],
	responses: %{
	200 => Operation.response("Account", "application/json", Account),
	401 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def statuses_operation do
	%Operation{
	summary: "Statuses",
	tags: ["Retrieve account information"],
	operationId: "AccountController.statuses",
	description:
	"Statuses posted to the given account. Public (for public statuses only), or user token + `read:statuses` (for private statuses the user is authorized to see)",
	parameters:
	[
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(:pinned, :query, BooleanLike, "Include only pinned statuses"),
	Operation.parameter(:tagged, :query, :string, "With tag"),
	Operation.parameter(
	:only_media,
	:query,
	BooleanLike,
	"Include only statuses with media attached"
	),
	Operation.parameter(
	:with_muted,
	:query,
	BooleanLike,
	"Include statuses from muted accounts."
	),
	Operation.parameter(:exclude_reblogs, :query, BooleanLike, "Exclude reblogs"),
	Operation.parameter(:exclude_replies, :query, BooleanLike, "Exclude replies"),
	Operation.parameter(
	:exclude_visibilities,
	:query,
	%Schema{type: :array, items: VisibilityScope},
	"Exclude visibilities"
	),
	Operation.parameter(
	:with_muted,
	:query,
	BooleanLike,
	"Include reactions from muted accounts."
	)
	] ++ pagination_params(),
	responses: %{
	200 => Operation.response("Statuses", "application/json", array_of_statuses()),
	401 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def followers_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Followers",
	operationId: "AccountController.followers",
	security: [%{"oAuth" => ["read:accounts"]}],
	description:
	"Accounts which follow the given account, if network is not hidden by the account owner.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(:id, :query, :string, "ID of the resource owner"),
	with_relationships_param() \| pagination_params()
	],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def following_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Following",
	operationId: "AccountController.following",
	security: [%{"oAuth" => ["read:accounts"]}],
	description:
	"Accounts which the given account is following, if network is not hidden by the account owner.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(:id, :query, :string, "ID of the resource owner"),
	with_relationships_param() \| pagination_params()
	],
	responses: %{200 => Operation.response("Accounts", "application/json", array_of_accounts())}
	}
	end

	def lists_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Lists containing this account",
	operationId: "AccountController.lists",
	security: [%{"oAuth" => ["read:lists"]}],
	description: "User lists that you have added this account to.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{200 => Operation.response("Lists", "application/json", array_of_lists())}
	}
	end

	def follow_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Follow",
	operationId: "AccountController.follow",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	description: "Follow the given account",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
	],
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	properties: %{
	reblogs: %Schema{
	allOf: [BooleanLike],
	description: "Receive this account's reblogs in home timeline? Defaults to true.",
	default: true
	},
	notify: %Schema{
	allOf: [BooleanLike],
	description:
	"Receive notifications for all statuses posted by the account? Defaults to false.",
	default: false
	}
	}
	},
	required: false
	),
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def unfollow_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Unfollow",
	operationId: "AccountController.unfollow",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	description: "Unfollow the given account",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def mute_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Mute",
	operationId: "AccountController.mute",
	security: [%{"oAuth" => ["follow", "write:mutes"]}],
	requestBody: request_body("Parameters", mute_request()),
	description:
	"Mute the given account. Clients should filter statuses and notifications from this account, if received (e.g. due to a boost in the Home timeline).",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(
	:notifications,
	:query,
	%Schema{allOf: [BooleanLike], default: true},
	"Mute notifications in addition to statuses? Defaults to `true`."
	),
	Operation.parameter(
	:duration,
	:query,
	%Schema{type: :integer},
	"Expire the mute in `duration` seconds. Default 0 for infinity"
	),
	Operation.parameter(
	:expires_in,
	:query,
	%Schema{type: :integer, default: 0},
	"Deprecated, use `duration` instead"
	)
	],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def unmute_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Unmute",
	operationId: "AccountController.unmute",
	security: [%{"oAuth" => ["follow", "write:mutes"]}],
	description: "Unmute the given account.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def block_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Block",
	operationId: "AccountController.block",
	security: [%{"oAuth" => ["follow", "write:blocks"]}],
	description:
	"Block the given account. Clients should filter statuses from this account if received (e.g. due to a boost in the Home timeline)",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def unblock_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Unblock",
	operationId: "AccountController.unblock",
	security: [%{"oAuth" => ["follow", "write:blocks"]}],
	description: "Unblock the given account.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def endorse_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Endorse",
	operationId: "AccountController.endorse",
	security: [%{"oAuth" => ["follow", "write:accounts"]}],
	description: "Adds the given account to endorsed accounts list.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 =>
	Operation.response("Bad Request", "application/json", %Schema{
	allOf: [ApiError],
	title: "Unprocessable Entity",
	example: %{
	"error" => "You have already pinned the maximum number of users"
	}
	})
	}
	}
	end

	def unendorse_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Unendorse",
	operationId: "AccountController.unendorse",
	security: [%{"oAuth" => ["follow", "write:accounts"]}],
	description: "Removes the given account from endorsed accounts list.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def remove_from_followers_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Remove from followers",
	operationId: "AccountController.remove_from_followers",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	description: "Remove the given account from followers",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def note_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Set a private note about a user.",
	operationId: "AccountController.note",
	security: [%{"oAuth" => ["follow", "write:accounts"]}],
	requestBody: request_body("Parameters", note_request()),
	description: "Create a note for the given account.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(
	:comment,
	:query,
	%Schema{type: :string},
	"Account note body"
	)
	],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def follow_by_uri_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Follow by URI",
	operationId: "AccountController.follows",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	requestBody: request_body("Parameters", follow_by_uri_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def mutes_operation do
	%Operation{
	tags: ["Blocks and mutes"],
	summary: "Retrieve list of mutes",
	operationId: "AccountController.mutes",
	description: "Accounts the user has muted.",
	security: [%{"oAuth" => ["follow", "read:mutes"]}],
	parameters: [with_relationships_param() \| pagination_params()],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def blocks_operation do
	%Operation{
	tags: ["Blocks and mutes"],
	summary: "Retrieve list of blocks",
	operationId: "AccountController.blocks",
	description: "View your blocks. See also accounts/:id/{block,unblock}",
	security: [%{"oAuth" => ["read:blocks"]}],
	parameters: [with_relationships_param() \| pagination_params()],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def lookup_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Find a user by nickname",
	operationId: "AccountController.lookup",
	parameters: [
	Operation.parameter(
	:acct,
	:query,
	:string,
	"User nickname"
	)
	],
	responses: %{
	200 => Operation.response("Account", "application/json", Account),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def endorsements_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Endorsements",
	operationId: "AccountController.endorsements",
	description: "Returns endorsed accounts",
	security: [%{"oAuth" => ["read:accounts"]}],
	responses: %{
	200 => Operation.response("Array of Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def identity_proofs_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Identity proofs",
	operationId: "AccountController.identity_proofs",
	# Validators complains about unused path params otherwise
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
	],
	description: "Not implemented",
	responses: %{
	200 => empty_array_response()
	}
	}
	end

	defp create_request do
	%Schema{
	title: "AccountCreateRequest",
	description: "POST body for creating an account",
	type: :object,
	required: [:username, :password, :agreement],
	properties: %{
	reason: %Schema{
	type: :string,
	nullable: true,
	description:
	"Text that will be reviewed by moderators if registrations require manual approval"
	},
	username: %Schema{type: :string, description: "The desired username for the account"},
	email: %Schema{
	type: :string,
	nullable: true,
	description:
	"The email address to be used for login. Required when `account_activation_required` is enabled.",
	format: :email
	},
	password: %Schema{
	type: :string,
	description: "The password to be used for login",
	format: :password
	},
	agreement: %Schema{
	allOf: [BooleanLike],
	description:
	"Whether the user agrees to the local rules, terms, and policies. These should be presented to the user in order to allow them to consent before setting this parameter to TRUE."
	},
	locale: %Schema{
	type: :string,
	nullable: true,
	description: "The language of the confirmation email that will be sent"
	},
	# Pleroma-specific properties:
	fullname: %Schema{type: :string, nullable: true, description: "Full name"},
	bio: %Schema{type: :string, description: "Bio", nullable: true, default: ""},
	captcha_solution: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha solution"
	},
	captcha_token: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha token"
	},
	captcha_answer_data: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha data"
	},
	token: %Schema{
	type: :string,
	nullable: true,
	description: "Invite token required when the registrations aren't public"
	},
	birthday: %Schema{
	nullable: true,
	description: "User's birthday",
	anyOf: [
	%Schema{
	type: :string,
	format: :date
	},
	%Schema{
	type: :string,
	maxLength: 0
	}
	]
	},
	language: %Schema{
	type: :string,
	nullable: true,
	description: "User's preferred language for emails"
	}
	},
	example: %{
	"username" => "cofe",
	"email" => "cofe@example.com",
	"password" => "secret",
	"agreement" => "true",
	"bio" => "☕️"
	}
	}
	end

	# Note: this is a token response (if login succeeds!), but there's no oauth operation file yet.
	defp create_response do
	%Schema{
	title: "AccountCreateResponse",
	description: "Response schema for an account",
	type: :object,
	properties: %{
	# The response when auto-login on create succeeds (token is issued):
	token_type: %Schema{type: :string},
	access_token: %Schema{type: :string},
	refresh_token: %Schema{type: :string},
	scope: %Schema{type: :string},
	created_at: %Schema{type: :integer, format: :"date-time"},
	me: %Schema{type: :string},
	expires_in: %Schema{type: :integer},
	#
	# The response when registration succeeds but auto-login fails (no token):
	identifier: %Schema{type: :string},
	message: %Schema{type: :string}
	},
	# Note: example of successful registration with failed login response:
	# example: %{
	# "identifier" => "missing_confirmed_email",
	# "message" => "You have been registered. Please check your email for further instructions."
	# },
	example: %{
	"token_type" => "Bearer",
	"access_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzk",
	"refresh_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzz",
	"created_at" => 1_585_918_714,
	"expires_in" => 600,
	"scope" => "read write follow push",
	"me" => "https://gensokyo.2hu/users/raymoo"
	}
	}
	end

	defp update_credentials_request do
	%Schema{
	title: "AccountUpdateCredentialsRequest",
	description: "POST body for creating an account",
	type: :object,
	properties: %{
	bot: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether the account has a bot flag."
	},
	display_name: %Schema{
	type: :string,
	nullable: true,
	description: "The display name to use for the profile."
	},
	note: %Schema{type: :string, description: "The account bio."},
	avatar: %Schema{
	type: :string,
	nullable: true,
	description: "Avatar image encoded using multipart/form-data",
	format: :binary
	},
	header: %Schema{
	type: :string,
	nullable: true,
	description: "Header image encoded using multipart/form-data",
	format: :binary
	},
	locked: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether manual approval of follow requests is required."
	},
	accepts_chat_messages: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether the user accepts receiving chat messages."
	},
	fields_attributes: %Schema{
	nullable: true,
	oneOf: [
	%Schema{type: :array, items: attribute_field()},
	%Schema{type: :object, additionalProperties: attribute_field()}
	]
	},
	# NOTE: `source` field is not supported
	#
	# source: %Schema{
	# type: :object,
	# properties: %{
	# privacy: %Schema{type: :string},
	# sensitive: %Schema{type: :boolean},
	# language: %Schema{type: :string}
	# }
	# },

	# Pleroma-specific fields
	no_rich_text: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "html tags are stripped from all statuses requested from the API"
	},
	hide_followers: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's followers will be hidden"
	},
	hide_follows: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follows will be hidden"
	},
	hide_followers_count: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follower count will be hidden"
	},
	hide_follows_count: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follow count will be hidden"
	},
	hide_favorites: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's favorites timeline will be hidden"
	},
	show_role: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's role (e.g admin, moderator) will be exposed to anyone in the
	API"
	},
	default_scope: VisibilityScope,
	pleroma_settings_store: %Schema{
	type: :object,
	nullable: true,
	description: "Opaque user settings to be saved on the backend."
	},
	skip_thread_containment: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Skip filtering out broken threads"
	},
	allow_following_move: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Allows automatically follow moved following accounts"
	},
	also_known_as: %Schema{
	type: :array,
	items: %Schema{type: :string},
	nullable: true,
	description: "List of alternate ActivityPub IDs"
	},
	pleroma_background_image: %Schema{
	type: :string,
	nullable: true,
	description: "Sets the background image of the user.",
	format: :binary
	},
	discoverable: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description:
	"Discovery (listing, indexing) of this account by external services (search bots etc.) is allowed."
	},
	actor_type: ActorType,
	birthday: %Schema{
	nullable: true,
	description: "User's birthday",
	anyOf: [
	%Schema{
	type: :string,
	format: :date
	},
	%Schema{
	type: :string,
	maxLength: 0
	}
	]
	},
	show_birthday: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "User's birthday will be visible"
	}
	},
	example: %{
	bot: false,
	display_name: "cofe",
	note: "foobar",
	fields_attributes: [%{name: "foo", value: "bar"}],
	no_rich_text: false,
	hide_followers: true,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	hide_favorites: false,
	show_role: false,
	default_scope: "private",
	pleroma_settings_store: %{"pleroma-fe" => %{"key" => "val"}},
	skip_thread_containment: false,
	allow_following_move: false,
	also_known_as: ["https://foo.bar/users/foo"],
	discoverable: false,
	actor_type: "Person",
	show_birthday: false,
	birthday: "2001-02-12"
	}
	}
	end

	def array_of_accounts do
	%Schema{
	title: "ArrayOfAccounts",
	type: :array,
	items: Account,
	example: [Account.schema().example]
	}
	end

	defp array_of_relationships do
	%Schema{
	title: "ArrayOfRelationships",
	description: "Response schema for account relationships",
	type: :array,
	items: AccountRelationship,
	example: [
	%{
	"id" => "1",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => false,
	"blocked_by" => true,
	"muting" => false,
	"muting_notifications" => false,
	"note" => "",
	"requested" => false,
	"domain_blocking" => false,
	"subscribing" => false,
	"notifying" => false,
	"endorsed" => true
	},
	%{
	"id" => "2",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => false,
	"blocked_by" => true,
	"muting" => true,
	"muting_notifications" => false,
	"note" => "",
	"requested" => true,
	"domain_blocking" => false,
	"subscribing" => false,
	"notifying" => false,
	"endorsed" => false
	},
	%{
	"id" => "3",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => true,
	"blocked_by" => false,
	"muting" => true,
	"muting_notifications" => false,
	"note" => "",
	"requested" => false,
	"domain_blocking" => true,
	"subscribing" => true,
	"notifying" => true,
	"endorsed" => false
	}
	]
	}
	end

	defp follow_by_uri_request do
	%Schema{
	title: "AccountFollowsRequest",
	description: "POST body for muting an account",
	type: :object,
	properties: %{
	- uri: %Schema{type: :string, nullable: true, format: :uri}
	+ "uri" => %Schema{type: :string, nullable: true, format: :uri}
	},
	- required: [:uri]
	+ required: ["uri"]
	}
	end

	defp mute_request do
	%Schema{
	title: "AccountMuteRequest",
	description: "POST body for muting an account",
	type: :object,
	properties: %{
	notifications: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Mute notifications in addition to statuses? Defaults to true.",
	default: true
	},
	duration: %Schema{
	type: :integer,
	nullable: true,
	description: "Expire the mute in `expires_in` seconds. Default 0 for infinity"
	},
	expires_in: %Schema{
	type: :integer,
	nullable: true,
	description: "Deprecated, use `duration` instead",
	default: 0
	}
	},
	example: %{
	"notifications" => true,
	"expires_in" => 86_400
	}
	}
	end

	defp note_request do
	%Schema{
	title: "AccountNoteRequest",
	description: "POST body for adding a note for an account",
	type: :object,
	properties: %{
	- comment: %Schema{
	+ "comment" => %Schema{
	type: :string,
	description: "Account note body"
	}
	},
	example: %{
	"comment" => "Example note"
	}
	}
	end

	defp array_of_lists do
	%Schema{
	title: "ArrayOfLists",
	description: "Response schema for lists",
	type: :array,
	items: List,
	example: [
	%{"id" => "123", "title" => "my list"},
	%{"id" => "1337", "title" => "anotehr list"}
	]
	}
	end

	defp array_of_statuses do
	%Schema{
	title: "ArrayOfStatuses",
	type: :array,
	items: Status
	}
	end

	defp attribute_field do
	%Schema{
	title: "AccountAttributeField",
	description: "Request schema for account custom fields",
	type: :object,
	properties: %{
	name: %Schema{type: :string},
	value: %Schema{type: :string}
	},
	required: [:name, :value],
	example: %{
	"name" => "Website",
	"value" => "https://pleroma.com"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/config_operation.ex b/lib/pleroma/web/api_spec/operations/admin/config_operation.ex
	index 487dd5cda..c528cacf2 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/config_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/config_operation.ex
	@@ -1,145 +1,145 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.ConfigOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def show_operation do
	%Operation{
	tags: ["Instance configuration"],
	summary: "Retrieve instance configuration",
	operationId: "AdminAPI.ConfigController.show",
	parameters: [
	Operation.parameter(
	:only_db,
	:query,
	%Schema{type: :boolean, default: false},
	"Get only saved in database settings"
	)
	\| admin_api_params()
	],
	security: [%{"oAuth" => ["admin:read"]}],
	responses: %{
	200 => Operation.response("Config", "application/json", config_response()),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Instance configuration"],
	summary: "Update instance configuration",
	operationId: "AdminAPI.ConfigController.update",
	security: [%{"oAuth" => ["admin:write"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	- configs: %Schema{
	+ "configs" => %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	group: %Schema{type: :string},
	key: %Schema{type: :string},
	value: any(),
	delete: %Schema{type: :boolean},
	subkeys: %Schema{type: :array, items: %Schema{type: :string}}
	}
	}
	}
	}
	}),
	responses: %{
	200 => Operation.response("Config", "application/json", config_response()),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	def descriptions_operation do
	%Operation{
	tags: ["Instance configuration"],
	summary: "Retrieve config description",
	operationId: "AdminAPI.ConfigController.descriptions",
	security: [%{"oAuth" => ["admin:read"]}],
	parameters: admin_api_params(),
	responses: %{
	200 =>
	Operation.response("Config Descriptions", "application/json", %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	group: %Schema{type: :string},
	key: %Schema{type: :string},
	type: %Schema{oneOf: [%Schema{type: :string}, %Schema{type: :array}]},
	description: %Schema{type: :string},
	children: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	key: %Schema{type: :string},
	type: %Schema{oneOf: [%Schema{type: :string}, %Schema{type: :array}]},
	description: %Schema{type: :string},
	suggestions: %Schema{type: :array}
	}
	}
	}
	}
	}
	}),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	defp any do
	%Schema{
	oneOf: [
	%Schema{type: :array},
	%Schema{type: :object},
	%Schema{type: :string},
	%Schema{type: :integer},
	%Schema{type: :boolean}
	]
	}
	end

	defp config_response do
	%Schema{
	type: :object,
	properties: %{
	configs: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	group: %Schema{type: :string},
	key: %Schema{type: :string},
	value: any()
	}
	}
	},
	need_reboot: %Schema{
	type: :boolean,
	description:
	"If `need_reboot` is `true`, instance must be restarted, so reboot time settings can take effect"
	}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/instance_document_operation.ex b/lib/pleroma/web/api_spec/operations/admin/instance_document_operation.ex
	index fc0de499b..b2a1ba8ad 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/instance_document_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/instance_document_operation.ex
	@@ -1,115 +1,115 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.InstanceDocumentOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Helpers
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def show_operation do
	%Operation{
	tags: ["Instance documents"],
	summary: "Retrieve an instance document",
	operationId: "AdminAPI.InstanceDocumentController.show",
	security: [%{"oAuth" => ["admin:read"]}],
	parameters: [
	Operation.parameter(:name, :path, %Schema{type: :string}, "The document name",
	required: true
	)
	\| Helpers.admin_api_params()
	],
	responses: %{
	200 => document_content(),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Instance documents"],
	summary: "Update an instance document",
	operationId: "AdminAPI.InstanceDocumentController.update",
	security: [%{"oAuth" => ["admin:write"]}],
	requestBody: Helpers.request_body("Parameters", update_request()),
	parameters: [
	Operation.parameter(:name, :path, %Schema{type: :string}, "The document name",
	required: true
	)
	\| Helpers.admin_api_params()
	],
	responses: %{
	200 => Operation.response("InstanceDocument", "application/json", instance_document()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	defp update_request do
	%Schema{
	title: "UpdateRequest",
	description: "POST body for uploading the file",
	type: :object,
	- required: [:file],
	+ required: ["file"],
	properties: %{
	- file: %Schema{
	+ "file" => %Schema{
	type: :string,
	format: :binary,
	description: "The file to be uploaded, using multipart form data."
	}
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Instance documents"],
	summary: "Delete an instance document",
	operationId: "AdminAPI.InstanceDocumentController.delete",
	security: [%{"oAuth" => ["admin:write"]}],
	parameters: [
	Operation.parameter(:name, :path, %Schema{type: :string}, "The document name",
	required: true
	)
	\| Helpers.admin_api_params()
	],
	responses: %{
	200 => Operation.response("InstanceDocument", "application/json", instance_document()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	defp instance_document do
	%Schema{
	title: "InstanceDocument",
	type: :object,
	properties: %{
	url: %Schema{type: :string}
	},
	example: %{
	"url" => "https://example.com/static/terms-of-service.html"
	}
	}
	end

	defp document_content do
	Operation.response("InstanceDocumentContent", "text/html", %Schema{
	type: :string,
	example: "<h1>Instance panel</h1>"
	})
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/invite_operation.ex b/lib/pleroma/web/api_spec/operations/admin/invite_operation.ex
	index e4a9ffaeb..3b084f3b8 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/invite_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/invite_operation.ex
	@@ -1,152 +1,152 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.InviteOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def index_operation do
	%Operation{
	tags: ["Invites"],
	summary: "Get a list of generated invites",
	operationId: "AdminAPI.InviteController.index",
	security: [%{"oAuth" => ["admin:read:invites"]}],
	parameters: admin_api_params(),
	responses: %{
	200 =>
	Operation.response("Invites", "application/json", %Schema{
	type: :object,
	properties: %{
	invites: %Schema{type: :array, items: invite()}
	},
	example: %{
	"invites" => [
	%{
	"id" => 123,
	"token" => "kSQtDj_GNy2NZsL9AQDFIsHN5qdbguB6qRg3WHw6K1U=",
	"used" => true,
	"expires_at" => nil,
	"uses" => 0,
	"max_use" => nil,
	"invite_type" => "one_time"
	}
	]
	}
	})
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["Invites"],
	summary: "Create an account registration invite token",
	operationId: "AdminAPI.InviteController.create",
	security: [%{"oAuth" => ["admin:write:invites"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	max_use: %Schema{type: :integer},
	expires_at: %Schema{type: :string, format: :date, example: "2020-04-20"}
	}
	}),
	responses: %{
	200 => Operation.response("Invite", "application/json", invite())
	}
	}
	end

	def revoke_operation do
	%Operation{
	tags: ["Invites"],
	summary: "Revoke invite by token",
	operationId: "AdminAPI.InviteController.revoke",
	security: [%{"oAuth" => ["admin:write:invites"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	- required: [:token],
	+ required: ["token"],
	properties: %{
	- token: %Schema{type: :string}
	+ "token" => %Schema{type: :string}
	}
	},
	required: true
	),
	responses: %{
	200 => Operation.response("Invite", "application/json", invite()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def email_operation do
	%Operation{
	tags: ["Invites"],
	summary: "Sends registration invite via email",
	operationId: "AdminAPI.InviteController.email",
	security: [%{"oAuth" => ["admin:write:invites"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	- required: [:email],
	+ required: ["email"],
	properties: %{
	- email: %Schema{type: :string, format: :email},
	- name: %Schema{type: :string}
	+ "email" => %Schema{type: :string, format: :email},
	+ "name" => %Schema{type: :string}
	}
	},
	required: true
	),
	responses: %{
	204 => no_content_response(),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	defp invite do
	%Schema{
	title: "Invite",
	type: :object,
	properties: %{
	id: %Schema{type: :integer},
	token: %Schema{type: :string},
	used: %Schema{type: :boolean},
	expires_at: %Schema{type: :string, format: :date, nullable: true},
	uses: %Schema{type: :integer},
	max_use: %Schema{type: :integer, nullable: true},
	invite_type: %Schema{
	type: :string,
	enum: ["one_time", "reusable", "date_limited", "reusable_date_limited"]
	}
	},
	example: %{
	"id" => 123,
	"token" => "kSQtDj_GNy2NZsL9AQDFIsHN5qdbguB6qRg3WHw6K1U=",
	"used" => true,
	"expires_at" => nil,
	"uses" => 0,
	"max_use" => nil,
	"invite_type" => "one_time"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/media_proxy_cache_operation.ex b/lib/pleroma/web/api_spec/operations/admin/media_proxy_cache_operation.ex
	index 0b1eb3946..79363d4cd 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/media_proxy_cache_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/media_proxy_cache_operation.ex
	@@ -1,121 +1,121 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.MediaProxyCacheOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def index_operation do
	%Operation{
	tags: ["MediaProxy cache"],
	summary: "Retrieve a list of banned MediaProxy URLs",
	operationId: "AdminAPI.MediaProxyCacheController.index",
	security: [%{"oAuth" => ["admin:read:media_proxy_caches"]}],
	parameters: [
	Operation.parameter(
	:query,
	:query,
	%Schema{type: :string, default: nil},
	"Page"
	),
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number of statuses to return"
	)
	\| admin_api_params()
	],
	responses: %{
	200 =>
	Operation.response(
	"Array of MediaProxy URLs",
	"application/json",
	%Schema{
	type: :object,
	properties: %{
	count: %Schema{type: :integer},
	page_size: %Schema{type: :integer},
	urls: %Schema{
	type: :array,
	items: %Schema{
	type: :string,
	format: :uri,
	description: "MediaProxy URLs"
	}
	}
	}
	}
	)
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["MediaProxy cache"],
	summary: "Remove a banned MediaProxy URL",
	operationId: "AdminAPI.MediaProxyCacheController.delete",
	security: [%{"oAuth" => ["admin:write:media_proxy_caches"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	- required: [:urls],
	+ required: ["urls"],
	properties: %{
	- urls: %Schema{type: :array, items: %Schema{type: :string, format: :uri}}
	+ "urls" => %Schema{type: :array, items: %Schema{type: :string, format: :uri}}
	}
	},
	required: true
	),
	responses: %{
	200 => empty_object_response(),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def purge_operation do
	%Operation{
	tags: ["MediaProxy cache"],
	summary: "Purge a URL from MediaProxy cache and optionally ban it",
	operationId: "AdminAPI.MediaProxyCacheController.purge",
	security: [%{"oAuth" => ["admin:write:media_proxy_caches"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	- required: [:urls],
	+ required: ["urls"],
	properties: %{
	- urls: %Schema{type: :array, items: %Schema{type: :string, format: :uri}},
	- ban: %Schema{type: :boolean, default: true}
	+ "urls" => %Schema{type: :array, items: %Schema{type: :string, format: :uri}},
	+ "ban" => %Schema{type: :boolean, default: true}
	}
	},
	required: true
	),
	responses: %{
	200 => empty_object_response(),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex b/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	index 8b241bd49..ca9080fb3 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	@@ -1,104 +1,104 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.RelayOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def index_operation do
	%Operation{
	tags: ["Relays"],
	summary: "Retrieve a list of relays",
	operationId: "AdminAPI.RelayController.index",
	security: [%{"oAuth" => ["admin:read"]}],
	parameters: admin_api_params(),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{
	relays: %Schema{
	type: :array,
	items: relay()
	}
	}
	})
	}
	}
	end

	def follow_operation do
	%Operation{
	tags: ["Relays"],
	summary: "Follow a relay",
	operationId: "AdminAPI.RelayController.follow",
	security: [%{"oAuth" => ["admin:write:follows"]}],
	parameters: admin_api_params(),
	requestBody: request_body("Parameters", relay_url()),
	responses: %{
	200 => Operation.response("Status", "application/json", relay())
	}
	}
	end

	def unfollow_operation do
	%Operation{
	tags: ["Relays"],
	summary: "Unfollow a relay",
	operationId: "AdminAPI.RelayController.unfollow",
	security: [%{"oAuth" => ["admin:write:follows"]}],
	parameters: admin_api_params(),
	requestBody: request_body("Parameters", relay_unfollow()),
	responses: %{
	200 =>
	Operation.response("Status", "application/json", %Schema{
	type: :string,
	example: "http://mastodon.example.org/users/admin"
	})
	}
	}
	end

	defp relay do
	%Schema{
	type: :object,
	properties: %{
	actor: %Schema{
	type: :string,
	example: "https://example.com/relay"
	},
	followed_back: %Schema{
	type: :boolean,
	description: "Is relay followed back by this actor?"
	}
	}
	}
	end

	defp relay_url do
	%Schema{
	type: :object,
	properties: %{
	- relay_url: %Schema{type: :string, format: :uri}
	+ "relay_url" => %Schema{type: :string, format: :uri}
	}
	}
	end

	defp relay_unfollow do
	%Schema{
	type: :object,
	properties: %{
	- relay_url: %Schema{type: :string, format: :uri},
	- force: %Schema{type: :boolean, default: false}
	+ "relay_url" => %Schema{type: :string, format: :uri},
	+ "force" => %Schema{type: :boolean, default: false}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/report_operation.ex b/lib/pleroma/web/api_spec/operations/admin/report_operation.ex
	index d7a74f665..3902f12f1 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/report_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/report_operation.ex
	@@ -1,240 +1,240 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.ReportOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.Schemas.Status

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def index_operation do
	%Operation{
	tags: ["Report management"],
	summary: "Retrieve a list of reports",
	operationId: "AdminAPI.ReportController.index",
	security: [%{"oAuth" => ["admin:read:reports"]}],
	parameters: [
	Operation.parameter(
	:state,
	:query,
	report_state(),
	"Filter by report state"
	),
	Operation.parameter(
	:limit,
	:query,
	%Schema{type: :integer},
	"The number of records to retrieve"
	),
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page number"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number number of log entries per page"
	)
	\| admin_api_params()
	],
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{
	total: %Schema{type: :integer},
	reports: %Schema{
	type: :array,
	items: report()
	}
	}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Report management"],
	summary: "Retrieve a report",
	operationId: "AdminAPI.ReportController.show",
	parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["admin:read:reports"]}],
	responses: %{
	200 => Operation.response("Report", "application/json", report()),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Report management"],
	summary: "Change state of specified reports",
	operationId: "AdminAPI.ReportController.update",
	security: [%{"oAuth" => ["admin:write:reports"]}],
	parameters: admin_api_params(),
	requestBody: request_body("Parameters", update_request(), required: true),
	responses: %{
	204 => no_content_response(),
	400 => Operation.response("Bad Request", "application/json", update_400_response()),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def notes_create_operation do
	%Operation{
	tags: ["Report management"],
	summary: "Add a note to the report",
	operationId: "AdminAPI.ReportController.notes_create",
	parameters: [id_param() \| admin_api_params()],
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	- content: %Schema{type: :string, description: "The message"}
	+ "content" => %Schema{type: :string, description: "The message"}
	}
	}),
	security: [%{"oAuth" => ["admin:write:reports"]}],
	responses: %{
	204 => no_content_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def notes_delete_operation do
	%Operation{
	tags: ["Report management"],
	summary: "Delete note attached to the report",
	operationId: "AdminAPI.ReportController.notes_delete",
	parameters: [
	Operation.parameter(:report_id, :path, :string, "Report ID"),
	Operation.parameter(:id, :path, :string, "Note ID")
	\| admin_api_params()
	],
	security: [%{"oAuth" => ["admin:write:reports"]}],
	responses: %{
	204 => no_content_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def report_state do
	%Schema{type: :string, enum: ["open", "closed", "resolved"]}
	end

	def id_param do
	Operation.parameter(:id, :path, FlakeID, "Report ID",
	example: "9umDrYheeY451cQnEe",
	required: true
	)
	end

	defp report do
	%Schema{
	type: :object,
	properties: %{
	id: FlakeID,
	state: report_state(),
	account: account_admin(),
	actor: account_admin(),
	content: %Schema{type: :string},
	created_at: %Schema{type: :string, format: :"date-time"},
	statuses: %Schema{type: :array, items: Status},
	notes: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	id: %Schema{type: :integer},
	user_id: FlakeID,
	content: %Schema{type: :string},
	inserted_at: %Schema{type: :string, format: :"date-time"}
	}
	}
	}
	}
	}
	end

	defp account_admin do
	%Schema{
	title: "Account",
	description: "Account view for admins",
	type: :object,
	properties:
	Map.merge(Account.schema().properties, %{
	nickname: %Schema{type: :string},
	is_active: %Schema{type: :boolean},
	local: %Schema{type: :boolean},
	roles: %Schema{
	type: :object,
	properties: %{
	admin: %Schema{type: :boolean},
	moderator: %Schema{type: :boolean}
	}
	},
	is_confirmed: %Schema{type: :boolean}
	})
	}
	end

	defp update_request do
	%Schema{
	type: :object,
	- required: [:reports],
	+ required: ["reports"],
	properties: %{
	- reports: %Schema{
	+ "reports" => %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	id: %Schema{allOf: [FlakeID], description: "Required, report ID"},
	state: %Schema{
	type: :string,
	description:
	"Required, the new state. Valid values are `open`, `closed` and `resolved`"
	}
	}
	},
	example: %{
	"reports" => [
	%{"id" => "123", "state" => "closed"},
	%{"id" => "1337", "state" => "resolved"}
	]
	}
	}
	}
	}
	end

	defp update_400_response do
	%Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	id: %Schema{allOf: [FlakeID], description: "Report ID"},
	error: %Schema{type: :string, description: "Error message"}
	}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/user_operation.ex b/lib/pleroma/web/api_spec/operations/admin/user_operation.ex
	index a5179ac39..49f5a4786 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/user_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/user_operation.ex
	@@ -1,453 +1,453 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.UserOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ActorType
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def index_operation do
	%Operation{
	tags: ["User administration"],
	summary: "List users",
	operationId: "AdminAPI.UserController.index",
	security: [%{"oAuth" => ["admin:read:accounts"]}],
	parameters: [
	Operation.parameter(:filters, :query, :string, "Comma separated list of filters"),
	Operation.parameter(:query, :query, :string, "Search users query"),
	Operation.parameter(:name, :query, :string, "Search by display name"),
	Operation.parameter(:email, :query, :string, "Search by email"),
	Operation.parameter(:page, :query, :integer, "Page Number"),
	Operation.parameter(:page_size, :query, :integer, "Number of users to return per page"),
	Operation.parameter(
	:actor_types,
	:query,
	%Schema{type: :array, items: ActorType},
	"Filter by actor type"
	),
	Operation.parameter(
	:tags,
	:query,
	%Schema{type: :array, items: %Schema{type: :string}},
	"Filter by tags"
	)
	\| admin_api_params()
	],
	responses: %{
	200 =>
	Operation.response(
	"Response",
	"application/json",
	%Schema{
	type: :object,
	properties: %{
	- users: %Schema{type: :array, items: user()},
	+ "users" => %Schema{type: :array, items: user()},
	count: %Schema{type: :integer},
	page_size: %Schema{type: :integer}
	}
	}
	),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Create a single or multiple users",
	operationId: "AdminAPI.UserController.create",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for creating users",
	type: :object,
	properties: %{
	- users: %Schema{
	+ "users" => %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	nickname: %Schema{type: :string},
	email: %Schema{type: :string},
	password: %Schema{type: :string}
	}
	}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	code: %Schema{type: :integer},
	type: %Schema{type: :string},
	data: %Schema{
	type: :object,
	properties: %{
	email: %Schema{type: :string, format: :email},
	nickname: %Schema{type: :string}
	}
	}
	}
	}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	409 =>
	Operation.response("Conflict", "application/json", %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	code: %Schema{type: :integer},
	error: %Schema{type: :string},
	type: %Schema{type: :string},
	data: %Schema{
	type: :object,
	properties: %{
	email: %Schema{type: :string, format: :email},
	nickname: %Schema{type: :string}
	}
	}
	}
	}
	})
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Show user",
	operationId: "AdminAPI.UserController.show",
	security: [%{"oAuth" => ["admin:read:accounts"]}],
	parameters: [
	Operation.parameter(
	:nickname,
	:path,
	:string,
	"User nickname or ID"
	)
	\| admin_api_params()
	],
	responses: %{
	200 => Operation.response("Response", "application/json", user()),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def follow_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Follow",
	operationId: "AdminAPI.UserController.follow",
	security: [%{"oAuth" => ["admin:write:follows"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	properties: %{
	- follower: %Schema{type: :string, description: "Follower nickname"},
	- followed: %Schema{type: :string, description: "Followed nickname"}
	+ "follower" => %Schema{type: :string, description: "Follower nickname"},
	+ "followed" => %Schema{type: :string, description: "Followed nickname"}
	}
	}
	),
	responses: %{
	200 => Operation.response("Response", "application/json", %Schema{type: :string}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def unfollow_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Unfollow",
	operationId: "AdminAPI.UserController.unfollow",
	security: [%{"oAuth" => ["admin:write:follows"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	properties: %{
	- follower: %Schema{type: :string, description: "Follower nickname"},
	- followed: %Schema{type: :string, description: "Followed nickname"}
	+ "follower" => %Schema{type: :string, description: "Follower nickname"},
	+ "followed" => %Schema{type: :string, description: "Followed nickname"}
	}
	}
	),
	responses: %{
	200 => Operation.response("Response", "application/json", %Schema{type: :string}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def approve_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Approve multiple users",
	operationId: "AdminAPI.UserController.approve",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for approving multiple users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def suggest_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Suggest multiple users",
	operationId: "AdminAPI.UserController.suggest",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for adding multiple suggested users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def unsuggest_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Unsuggest multiple users",
	operationId: "AdminAPI.UserController.unsuggest",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for removing multiple suggested users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def toggle_activation_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Toggle user activation",
	operationId: "AdminAPI.UserController.toggle_activation",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: [
	Operation.parameter(:nickname, :path, :string, "User nickname")
	\| admin_api_params()
	],
	responses: %{
	200 => Operation.response("Response", "application/json", user()),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def activate_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Activate multiple users",
	operationId: "AdminAPI.UserController.activate",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for deleting multiple users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def deactivate_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Deactivates multiple users",
	operationId: "AdminAPI.UserController.deactivate",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for deleting multiple users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{user: %Schema{type: :array, items: user()}}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["User administration"],
	summary: "Removes a single or multiple users",
	operationId: "AdminAPI.UserController.delete",
	security: [%{"oAuth" => ["admin:write:accounts"]}],
	parameters: [
	Operation.parameter(
	:nickname,
	:query,
	:string,
	"User nickname"
	)
	\| admin_api_params()
	],
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	description: "POST body for deleting multiple users",
	type: :object,
	properties: %{
	- nicknames: %Schema{
	+ "nicknames" => %Schema{
	type: :array,
	items: %Schema{type: :string}
	}
	}
	}
	),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	description: "Array of nicknames",
	type: :array,
	items: %Schema{type: :string}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	defp user do
	%Schema{
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	email: %Schema{type: :string, format: :email},
	avatar: %Schema{type: :string, format: :uri},
	nickname: %Schema{type: :string},
	display_name: %Schema{type: :string},
	is_active: %Schema{type: :boolean},
	local: %Schema{type: :boolean},
	roles: %Schema{
	type: :object,
	properties: %{
	admin: %Schema{type: :boolean},
	moderator: %Schema{type: :boolean}
	}
	},
	tags: %Schema{type: :array, items: %Schema{type: :string}},
	is_confirmed: %Schema{type: :boolean},
	is_approved: %Schema{type: :boolean},
	url: %Schema{type: :string, format: :uri},
	registration_reason: %Schema{type: :string, nullable: true},
	actor_type: %Schema{type: :string}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/chat_operation.ex b/lib/pleroma/web/api_spec/operations/chat_operation.ex
	index cf6a055fc..cee39f9d3 100644
	--- a/lib/pleroma/web/api_spec/operations/chat_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/chat_operation.ex
	@@ -1,383 +1,383 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.ChatOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	alias Pleroma.Web.ApiSpec.Schemas.Chat
	alias Pleroma.Web.ApiSpec.Schemas.ChatMessage

	import Pleroma.Web.ApiSpec.Helpers

	@spec open_api_operation(atom) :: Operation.t()
	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def mark_as_read_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Mark all messages in the chat as read",
	operationId: "ChatController.mark_as_read",
	parameters: [Operation.parameter(:id, :path, :string, "The ID of the Chat")],
	requestBody: request_body("Parameters", mark_as_read()),
	responses: %{
	200 =>
	Operation.response(
	"The updated chat",
	"application/json",
	Chat
	)
	},
	security: [
	%{
	"oAuth" => ["write:chats"]
	}
	]
	}
	end

	def mark_message_as_read_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Mark a message as read",
	operationId: "ChatController.mark_message_as_read",
	parameters: [
	Operation.parameter(:id, :path, :string, "The ID of the Chat"),
	Operation.parameter(:message_id, :path, :string, "The ID of the message")
	],
	responses: %{
	200 =>
	Operation.response(
	"The read ChatMessage",
	"application/json",
	ChatMessage
	)
	},
	security: [
	%{
	"oAuth" => ["write:chats"]
	}
	]
	}
	end

	def show_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Retrieve a chat",
	operationId: "ChatController.show",
	parameters: [
	Operation.parameter(
	:id,
	:path,
	:string,
	"The id of the chat",
	required: true,
	example: "1234"
	)
	],
	responses: %{
	200 =>
	Operation.response(
	"The existing chat",
	"application/json",
	Chat
	)
	},
	security: [
	%{
	"oAuth" => ["read"]
	}
	]
	}
	end

	def create_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Create a chat",
	operationId: "ChatController.create",
	parameters: [
	Operation.parameter(
	:id,
	:path,
	:string,
	"The account id of the recipient of this chat",
	required: true,
	example: "someflakeid"
	)
	],
	responses: %{
	200 =>
	Operation.response(
	"The created or existing chat",
	"application/json",
	Chat
	)
	},
	security: [
	%{
	"oAuth" => ["write:chats"]
	}
	]
	}
	end

	def index_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Retrieve list of chats (unpaginated)",
	deprecated: true,
	description:
	"Deprecated due to no support for pagination. Using [/api/v2/pleroma/chats](#operation/ChatController.index2) instead is recommended.",
	operationId: "ChatController.index",
	parameters: [
	Operation.parameter(:with_muted, :query, BooleanLike, "Include chats from muted users")
	],
	responses: %{
	200 => Operation.response("The chats of the user", "application/json", chats_response())
	},
	security: [
	%{
	"oAuth" => ["read:chats"]
	}
	]
	}
	end

	def index2_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Retrieve list of chats",
	operationId: "ChatController.index2",
	parameters: [
	Operation.parameter(:with_muted, :query, BooleanLike, "Include chats from muted users")
	\| pagination_params()
	],
	responses: %{
	200 => Operation.response("The chats of the user", "application/json", chats_response())
	},
	security: [
	%{
	"oAuth" => ["read:chats"]
	}
	]
	}
	end

	def messages_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Retrieve chat's messages",
	operationId: "ChatController.messages",
	parameters:
	[Operation.parameter(:id, :path, :string, "The ID of the Chat")] ++
	pagination_params(),
	responses: %{
	200 =>
	Operation.response(
	"The messages in the chat",
	"application/json",
	chat_messages_response()
	),
	404 => Operation.response("Not Found", "application/json", ApiError)
	},
	security: [
	%{
	"oAuth" => ["read:chats"]
	}
	]
	}
	end

	def post_chat_message_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Post a message to the chat",
	operationId: "ChatController.post_chat_message",
	parameters: [
	Operation.parameter(:id, :path, :string, "The ID of the Chat")
	],
	requestBody: request_body("Parameters", chat_message_create()),
	responses: %{
	200 =>
	Operation.response(
	"The newly created ChatMessage",
	"application/json",
	ChatMessage
	),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	422 => Operation.response("MRF Rejection", "application/json", ApiError)
	},
	security: [
	%{
	"oAuth" => ["write:chats"]
	}
	]
	}
	end

	def delete_message_operation do
	%Operation{
	tags: ["Chats"],
	summary: "Delete message",
	operationId: "ChatController.delete_message",
	parameters: [
	Operation.parameter(:id, :path, :string, "The ID of the Chat"),
	Operation.parameter(:message_id, :path, :string, "The ID of the message")
	],
	responses: %{
	200 =>
	Operation.response(
	"The deleted ChatMessage",
	"application/json",
	ChatMessage
	)
	},
	security: [
	%{
	"oAuth" => ["write:chats"]
	}
	]
	}
	end

	def chats_response do
	%Schema{
	title: "ChatsResponse",
	description: "Response schema for multiple Chats",
	type: :array,
	items: Chat,
	example: [
	%{
	"account" => %{
	"pleroma" => %{
	"is_admin" => false,
	"is_confirmed" => true,
	"hide_followers_count" => false,
	"is_moderator" => false,
	"hide_favorites" => true,
	"ap_id" => "https://dontbulling.me/users/lain",
	"hide_follows_count" => false,
	"hide_follows" => false,
	"background_image" => nil,
	"skip_thread_containment" => false,
	"hide_followers" => false,
	"relationship" => %{},
	"tags" => []
	},
	"avatar" =>
	"https://dontbulling.me/media/065a4dd3c6740dab13ff9c71ec7d240bb9f8be9205c9e7467fb2202117da1e32.jpg",
	"following_count" => 0,
	"header_static" => "https://originalpatchou.li/images/banner.png",
	"source" => %{
	"sensitive" => false,
	"note" => "lain",
	"pleroma" => %{
	"discoverable" => false,
	"actor_type" => "Person"
	},
	"fields" => []
	},
	"statuses_count" => 1,
	"locked" => false,
	"created_at" => "2020-04-16T13:40:15.000Z",
	"display_name" => "lain",
	"fields" => [],
	"acct" => "lain@dontbulling.me",
	"id" => "9u6Qw6TAZANpqokMkK",
	"emojis" => [],
	"avatar_static" =>
	"https://dontbulling.me/media/065a4dd3c6740dab13ff9c71ec7d240bb9f8be9205c9e7467fb2202117da1e32.jpg",
	"username" => "lain",
	"followers_count" => 0,
	"header" => "https://originalpatchou.li/images/banner.png",
	"bot" => false,
	"note" => "lain",
	"url" => "https://dontbulling.me/users/lain"
	},
	"id" => "1",
	"unread" => 2
	}
	]
	}
	end

	def chat_messages_response do
	%Schema{
	title: "ChatMessagesResponse",
	description: "Response schema for multiple ChatMessages",
	type: :array,
	items: ChatMessage,
	example: [
	%{
	"emojis" => [
	%{
	"static_url" => "https://dontbulling.me/emoji/Firefox.gif",
	"visible_in_picker" => false,
	"shortcode" => "firefox",
	"url" => "https://dontbulling.me/emoji/Firefox.gif"
	}
	],
	"created_at" => "2020-04-21T15:11:46.000Z",
	"content" => "Check this out :firefox:",
	"id" => "13",
	"chat_id" => "1",
	"account_id" => "someflakeid",
	"unread" => false
	},
	%{
	"account_id" => "someflakeid",
	"content" => "Whats' up?",
	"id" => "12",
	"chat_id" => "1",
	"emojis" => [],
	"created_at" => "2020-04-21T15:06:45.000Z",
	"unread" => false
	}
	]
	}
	end

	def chat_message_create do
	%Schema{
	title: "ChatMessageCreateRequest",
	description: "POST body for creating an chat message",
	type: :object,
	properties: %{
	content: %Schema{
	type: :string,
	description: "The content of your message. Optional if media_id is present"
	},
	media_id: %Schema{type: :string, description: "The id of an upload"}
	},
	example: %{
	"content" => "Hey wanna buy feet pics?",
	"media_id" => "134234"
	}
	}
	end

	def mark_as_read do
	%Schema{
	title: "MarkAsReadRequest",
	description: "POST body for marking a number of chat messages as read",
	type: :object,
	- required: [:last_read_id],
	+ required: ["last_read_id"],
	properties: %{
	- last_read_id: %Schema{
	+ "last_read_id" => %Schema{
	type: :string,
	description: "The content of your message."
	}
	},
	example: %{
	"last_read_id" => "abcdef12456"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex
	index b05bad197..ebb32f448 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex
	@@ -1,144 +1,144 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.PleromaEmojiFileOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def create_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Add new file to the pack",
	operationId: "PleromaAPI.EmojiPackController.add_file",
	security: [%{"oAuth" => ["admin:write"]}],
	requestBody: request_body("Parameters", create_request(), required: true),
	parameters: [name_param()],
	responses: %{
	200 => Operation.response("Files Object", "application/json", files_object()),
	422 => Operation.response("Unprocessable Entity", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	409 => Operation.response("Conflict", "application/json", ApiError),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp create_request do
	%Schema{
	type: :object,
	- required: [:file],
	+ required: ["file"],
	properties: %{
	- file: %Schema{
	+ "file" => %Schema{
	description:
	"File needs to be uploaded with the multipart request or link to remote file",
	anyOf: [
	%Schema{type: :string, format: :binary},
	%Schema{type: :string, format: :uri}
	]
	},
	- shortcode: %Schema{
	+ "shortcode" => %Schema{
	type: :string,
	description:
	"Shortcode for new emoji, must be unique for all emoji. If not sended, shortcode will be taken from original filename."
	},
	- filename: %Schema{
	+ "filename" => %Schema{
	type: :string,
	description:
	"New emoji file name. If not specified will be taken from original filename."
	}
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Add new file to the pack",
	operationId: "PleromaAPI.EmojiPackController.update_file",
	security: [%{"oAuth" => ["admin:write"]}],
	requestBody: request_body("Parameters", update_request(), required: true),
	parameters: [name_param()],
	responses: %{
	200 => Operation.response("Files Object", "application/json", files_object()),
	404 => Operation.response("Not Found", "application/json", ApiError),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	409 => Operation.response("Conflict", "application/json", ApiError),
	422 => Operation.response("Unprocessable Entity", "application/json", ApiError)
	}
	}
	end

	defp update_request do
	%Schema{
	type: :object,
	- required: [:shortcode, :new_shortcode, :new_filename],
	+ required: ["shortcode", "new_shortcode", "new_filename"],
	properties: %{
	- shortcode: %Schema{
	+ "shortcode" => %Schema{
	type: :string,
	description: "Emoji file shortcode"
	},
	- new_shortcode: %Schema{
	+ "new_shortcode" => %Schema{
	type: :string,
	description: "New emoji file shortcode"
	},
	- new_filename: %Schema{
	+ "new_filename" => %Schema{
	type: :string,
	description: "New filename for emoji file"
	},
	- force: %Schema{
	+ "force" => %Schema{
	type: :boolean,
	description: "With true value to overwrite existing emoji with new shortcode",
	default: false
	}
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Delete emoji file from pack",
	operationId: "PleromaAPI.EmojiPackController.delete_file",
	security: [%{"oAuth" => ["admin:write"]}],
	parameters: [
	name_param(),
	Operation.parameter(:shortcode, :query, :string, "File shortcode",
	example: "cofe",
	required: true
	)
	],
	responses: %{
	200 => Operation.response("Files Object", "application/json", files_object()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError),
	422 => Operation.response("Unprocessable Entity", "application/json", ApiError)
	}
	}
	end

	defp name_param do
	Operation.parameter(:name, :query, :string, "Pack Name", example: "cofe", required: true)
	end

	defp files_object do
	%Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :string,
	description: "Filename of the emoji",
	extensions: %{"x-additionalPropertiesName": "Emoji name"}
	},
	description: "Object with emoji names as keys and filenames as values"
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	index efa36ffdc..1c2b2c2b7 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	@@ -1,349 +1,329 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.PleromaEmojiPackOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def remote_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Make request to another instance for emoji packs list",
	security: [%{"oAuth" => ["admin:write"]}],
	parameters: [
	url_param(),
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 30},
	"Number of emoji to return"
	)
	],
	operationId: "PleromaAPI.EmojiPackController.remote",
	responses: %{
	200 => emoji_packs_response(),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def index_operation do
	%Operation{
	tags: ["Emoji packs"],
	summary: "Lists local custom emoji packs",
	operationId: "PleromaAPI.EmojiPackController.index",
	parameters: [
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number of emoji packs to return"
	)
	],
	responses: %{
	200 => emoji_packs_response()
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Emoji packs"],
	summary: "Show emoji pack",
	operationId: "PleromaAPI.EmojiPackController.show",
	parameters: [
	name_param(),
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 30},
	"Number of emoji to return"
	)
	],
	responses: %{
	200 => Operation.response("Emoji Pack", "application/json", emoji_pack()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def archive_operation do
	%Operation{
	tags: ["Emoji packs"],
	summary: "Requests a local pack archive from the instance",
	operationId: "PleromaAPI.EmojiPackController.archive",
	parameters: [name_param()],
	responses: %{
	200 =>
	Operation.response("Archive file", "application/octet-stream", %Schema{
	type: :string,
	format: :binary
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def download_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Download pack from another instance",
	operationId: "PleromaAPI.EmojiPackController.download",
	security: [%{"oAuth" => ["admin:write"]}],
	requestBody: request_body("Parameters", download_request(), required: true),
	responses: %{
	200 => ok_response(),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp download_request do
	%Schema{
	type: :object,
	- required: [:url, :name],
	+ required: ["url", "name"],
	properties: %{
	- url: %Schema{
	+ "url" => %Schema{
	type: :string,
	format: :uri,
	description: "URL of the instance to download from"
	},
	- name: %Schema{type: :string, format: :uri, description: "Pack Name"},
	- as: %Schema{type: :string, format: :uri, description: "Save as"}
	+ "name" => %Schema{type: :string, format: :uri, description: "Pack Name"},
	+ "as" => %Schema{type: :string, format: :uri, description: "Save as"}
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Create an empty pack",
	operationId: "PleromaAPI.EmojiPackController.create",
	security: [%{"oAuth" => ["admin:write"]}],
	parameters: [name_param()],
	responses: %{
	200 => ok_response(),
	400 => Operation.response("Not Found", "application/json", ApiError),
	409 => Operation.response("Conflict", "application/json", ApiError),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Delete a custom emoji pack",
	operationId: "PleromaAPI.EmojiPackController.delete",
	security: [%{"oAuth" => ["admin:write"]}],
	parameters: [name_param()],
	responses: %{
	200 => ok_response(),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Updates (replaces) pack metadata",
	operationId: "PleromaAPI.EmojiPackController.update",
	security: [%{"oAuth" => ["admin:write"]}],
	requestBody: request_body("Parameters", update_request(), required: true),
	parameters: [name_param()],
	responses: %{
	200 => Operation.response("Metadata", "application/json", metadata()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def import_from_filesystem_operation do
	%Operation{
	tags: ["Emoji pack administration"],
	summary: "Imports packs from filesystem",
	operationId: "PleromaAPI.EmojiPackController.import",
	security: [%{"oAuth" => ["admin:write"]}],
	responses: %{
	200 =>
	Operation.response("Array of imported pack names", "application/json", %Schema{
	type: :array,
	items: %Schema{type: :string}
	})
	}
	}
	end

	defp name_param do
	Operation.parameter(:name, :query, :string, "Pack Name", example: "cofe", required: true)
	end

	defp url_param do
	Operation.parameter(
	:url,
	:query,
	%Schema{type: :string, format: :uri},
	"URL of the instance",
	required: true
	)
	end

	defp ok_response do
	Operation.response("Ok", "application/json", %Schema{type: :string, example: "ok"})
	end

	defp emoji_packs_response do
	Operation.response(
	"Emoji packs and the count",
	"application/json",
	%Schema{
	type: :object,
	properties: %{
	packs: %Schema{
	type: :object,
	description: "Object with pack names as keys and pack contents as values",
	additionalProperties: %Schema{
	emoji_pack()
	\| extensions: %{"x-additionalPropertiesName": "Pack name"}
	}
	},
	count: %Schema{
	type: :integer,
	description: "Number of emoji packs"
	}
	},
	example: %{
	"packs" => %{
	"emojos" => emoji_pack().example
	},
	"count" => 1
	}
	}
	)
	end

	defp emoji_pack do
	%Schema{
	title: "EmojiPack",
	type: :object,
	properties: %{
	files: files_object(),
	pack: %Schema{
	type: :object,
	properties: %{
	license: %Schema{type: :string},
	homepage: %Schema{type: :string, format: :uri},
	description: %Schema{type: :string},
	"can-download": %Schema{type: :boolean},
	"share-files": %Schema{type: :boolean},
	"download-sha256": %Schema{type: :string}
	}
	}
	},
	example: %{
	"files" => %{"emacs" => "emacs.png", "guix" => "guix.png"},
	"pack" => %{
	"license" => "Test license",
	"homepage" => "https://pleroma.social",
	"description" => "Test description",
	"can-download" => true,
	"share-files" => true,
	"download-sha256" => "57482F30674FD3DE821FF48C81C00DA4D4AF1F300209253684ABA7075E5FC238"
	}
	}
	}
	end

	defp files_object do
	%Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :string,
	description: "Filename",
	extensions: %{"x-additionalPropertiesName": "Emoji name"}
	},
	description: "Object with emoji names as keys and filenames as values"
	}
	end

	defp update_request do
	%Schema{
	type: :object,
	- properties: %{
	- metadata: %Schema{
	- type: :object,
	- description: "Metadata to replace the old one",
	- properties: %{
	- license: %Schema{type: :string},
	- homepage: %Schema{type: :string, format: :uri},
	- description: %Schema{type: :string},
	- "fallback-src": %Schema{
	- type: :string,
	- format: :uri,
	- description: "Fallback url to download pack from"
	- },
	- "fallback-src-sha256": %Schema{
	- type: :string,
	- description: "SHA256 encoded for fallback pack archive"
	- },
	- "share-files": %Schema{type: :boolean, description: "Is pack allowed for sharing?"}
	- }
	- }
	- }
	+ properties: %{"metadata" => metadata()}
	}
	end

	defp metadata do
	%Schema{
	type: :object,
	properties: %{
	license: %Schema{type: :string},
	homepage: %Schema{type: :string, format: :uri},
	description: %Schema{type: :string},
	"fallback-src": %Schema{
	type: :string,
	format: :uri,
	description: "Fallback url to download pack from"
	},
	"fallback-src-sha256": %Schema{
	type: :string,
	description: "SHA256 encoded for fallback pack archive"
	},
	"share-files": %Schema{type: :boolean, description: "Is pack allowed for sharing?"}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_mascot_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_mascot_operation.ex
	index 775e27219..49c50751b 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_mascot_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_mascot_operation.ex
	@@ -1,79 +1,79 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.PleromaMascotOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def show_operation do
	%Operation{
	tags: ["Mascot"],
	summary: "Retrieve mascot",
	security: [%{"oAuth" => ["read:accounts"]}],
	operationId: "PleromaAPI.MascotController.show",
	responses: %{
	200 => Operation.response("Mascot", "application/json", mascot())
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Mascot"],
	summary: "Set or clear mascot",
	description:
	"Behaves exactly the same as `POST /api/v1/upload`. Can only accept images - any attempt to upload non-image files will be met with `HTTP 415 Unsupported Media Type`.",
	operationId: "PleromaAPI.MascotController.update",
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	properties: %{
	- file: %Schema{type: :string, format: :binary}
	+ "file" => %Schema{type: :string, format: :binary}
	}
	},
	required: true
	),
	security: [%{"oAuth" => ["write:accounts"]}],
	responses: %{
	200 => Operation.response("Mascot", "application/json", mascot()),
	415 => Operation.response("Unsupported Media Type", "application/json", ApiError)
	}
	}
	end

	defp mascot do
	%Schema{
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	url: %Schema{type: :string, format: :uri},
	type: %Schema{type: :string},
	pleroma: %Schema{
	type: :object,
	properties: %{
	mime_type: %Schema{type: :string}
	}
	}
	},
	example: %{
	"id" => "abcdefg",
	"url" => "https://pleroma.example.org/media/abcdefg.png",
	"type" => "image",
	"pleroma" => %{
	"mime_type" => "image/png"
	}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_notification_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_notification_operation.ex
	index a994345db..79990cb78 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_notification_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_notification_operation.ex
	@@ -1,49 +1,52 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.PleromaNotificationOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.NotificationOperation
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def mark_as_read_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Mark notifications as read",
	description: "Query parameters are mutually exclusive.",
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	- id: %Schema{type: :integer, description: "A single notification ID to read"},
	- max_id: %Schema{type: :integer, description: "Read all notifications up to this ID"}
	+ "id" => %Schema{type: :integer, description: "A single notification ID to read"},
	+ "max_id" => %Schema{
	+ type: :integer,
	+ description: "Read all notifications up to this ID"
	+ }
	}
	}),
	security: [%{"oAuth" => ["write:notifications"]}],
	operationId: "PleromaAPI.NotificationController.mark_as_read",
	responses: %{
	200 =>
	Operation.response(
	"A Notification or array of Notifications",
	"application/json",
	%Schema{
	anyOf: [
	%Schema{type: :array, items: NotificationOperation.notification()},
	NotificationOperation.notification()
	]
	}
	),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex b/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	index 87af0d526..b536bb6c1 100644
	--- a/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/twitter_util_operation.ex
	@@ -1,442 +1,442 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.TwitterUtilOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def emoji_operation do
	%Operation{
	tags: ["Custom emojis"],
	summary: "List all custom emojis",
	operationId: "UtilController.emoji",
	parameters: [],
	responses: %{
	200 =>
	Operation.response("List", "application/json", %Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :object,
	properties: %{
	image_url: %Schema{type: :string},
	tags: %Schema{type: :array, items: %Schema{type: :string}}
	},
	extensions: %{"x-additionalPropertiesName": "Emoji name"}
	},
	example: %{
	"firefox" => %{
	"image_url" => "/emoji/firefox.png",
	"tag" => ["Fun"]
	}
	}
	})
	}
	}
	end

	def frontend_configurations_operation do
	%Operation{
	tags: ["Others"],
	summary: "Dump frontend configurations",
	operationId: "UtilController.frontend_configurations",
	parameters: [],
	responses: %{
	200 =>
	Operation.response("List", "application/json", %Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :object,
	description:
	"Opaque object representing the instance-wide configuration for the frontend",
	extensions: %{"x-additionalPropertiesName": "Frontend name"}
	}
	})
	}
	}
	end

	def change_password_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Change account password",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.change_password",
	requestBody: request_body("Parameters", change_password_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp change_password_request do
	%Schema{
	title: "ChangePasswordRequest",
	description: "POST body for changing the account's password",
	type: :object,
	required: [:password, :new_password, :new_password_confirmation],
	properties: %{
	password: %Schema{type: :string, description: "Current password"},
	new_password: %Schema{type: :string, description: "New password"},
	new_password_confirmation: %Schema{
	type: :string,
	description: "New password, confirmation"
	}
	}
	}
	end

	def change_email_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Change account email",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.change_email",
	requestBody: request_body("Parameters", change_email_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp change_email_request do
	%Schema{
	title: "ChangeEmailRequest",
	description: "POST body for changing the account's email",
	type: :object,
	required: [:email, :password],
	properties: %{
	email: %Schema{
	type: :string,
	description: "New email. Set to blank to remove the user's email."
	},
	password: %Schema{type: :string, description: "Current password"}
	}
	}
	end

	def update_notification_settings_operation do
	%Operation{
	tags: ["Settings"],
	summary: "Update Notification Settings",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.update_notification_settings",
	parameters: [
	Operation.parameter(
	:block_from_strangers,
	:query,
	BooleanLike,
	"blocks notifications from accounts you do not follow"
	),
	Operation.parameter(
	:hide_notification_contents,
	:query,
	BooleanLike,
	"removes the contents of a message from the push notification"
	)
	],
	requestBody: nil,
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def disable_account_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Disable Account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.disable_account",
	parameters: [
	Operation.parameter(:password, :query, :string, "Password")
	],
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def delete_account_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Delete Account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.delete_account",
	parameters: [
	Operation.parameter(:password, :query, :string, "Password")
	],
	requestBody: request_body("Parameters", delete_account_request(), required: false),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def captcha_operation do
	%Operation{
	summary: "Get a captcha",
	operationId: "UtilController.captcha",
	tags: ["Others"],
	parameters: [],
	responses: %{
	200 => Operation.response("Success", "application/json", %Schema{type: :object})
	}
	}
	end

	def move_account_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Move account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.move_account",
	requestBody: request_body("Parameters", move_account_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{status: %Schema{type: :string, example: "success"}}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp move_account_request do
	%Schema{
	title: "MoveAccountRequest",
	description: "POST body for moving the account",
	type: :object,
	required: [:password, :target_account],
	properties: %{
	password: %Schema{type: :string, description: "Current password"},
	target_account: %Schema{
	type: :string,
	description: "The nickname of the target account to move to"
	}
	}
	}
	end

	def list_aliases_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "List account aliases",
	security: [%{"oAuth" => ["read:accounts"]}],
	operationId: "UtilController.list_aliases",
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{
	aliases: %Schema{
	type: :array,
	items: %Schema{type: :string},
	example: ["foo@example.org"]
	}
	}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def add_alias_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Add an alias to this account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.add_alias",
	requestBody: request_body("Parameters", add_alias_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{
	status: %Schema{
	type: :string,
	example: "success"
	}
	}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp add_alias_request do
	%Schema{
	title: "AddAliasRequest",
	description: "PUT body for adding aliases",
	type: :object,
	required: [:alias],
	properties: %{
	alias: %Schema{
	type: :string,
	description: "The nickname of the account to add to aliases"
	}
	}
	}
	end

	def delete_alias_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Delete an alias from this account",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.delete_alias",
	requestBody: request_body("Parameters", delete_alias_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Success", "application/json", %Schema{
	type: :object,
	properties: %{
	status: %Schema{
	type: :string,
	example: "success"
	}
	}
	}),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp delete_alias_request do
	%Schema{
	title: "DeleteAliasRequest",
	description: "PUT body for deleting aliases",
	type: :object,
	required: [:alias],
	properties: %{
	alias: %Schema{
	type: :string,
	description: "The nickname of the account to delete from aliases"
	}
	}
	}
	end

	def healthcheck_operation do
	%Operation{
	tags: ["Others"],
	summary: "Quick status check on the instance",
	security: [%{"oAuth" => ["write:accounts"]}],
	operationId: "UtilController.healthcheck",
	parameters: [],
	responses: %{
	200 => Operation.response("Healthy", "application/json", %Schema{type: :object}),
	503 =>
	Operation.response("Disabled or Unhealthy", "application/json", %Schema{type: :object})
	}
	}
	end

	def remote_subscribe_operation do
	%Operation{
	tags: ["Remote interaction"],
	summary: "Remote Subscribe",
	operationId: "UtilController.remote_subscribe",
	parameters: [],
	responses: %{200 => Operation.response("Web Page", "test/html", %Schema{type: :string})}
	}
	end

	def remote_interaction_operation do
	%Operation{
	tags: ["Remote interaction"],
	summary: "Remote interaction",
	operationId: "UtilController.remote_interaction",
	requestBody: request_body("Parameters", remote_interaction_request(), required: true),
	responses: %{
	200 =>
	Operation.response("Remote interaction URL", "application/json", %Schema{type: :object})
	}
	}
	end

	defp remote_interaction_request do
	%Schema{
	title: "RemoteInteractionRequest",
	description: "POST body for remote interaction",
	type: :object,
	- required: [:ap_id, :profile],
	+ required: ["ap_id", "profile"],
	properties: %{
	- ap_id: %Schema{type: :string, description: "Profile or status ActivityPub ID"},
	- profile: %Schema{type: :string, description: "Remote profile webfinger"}
	+ "ap_id" => %Schema{type: :string, description: "Profile or status ActivityPub ID"},
	+ "profile" => %Schema{type: :string, description: "Remote profile webfinger"}
	}
	}
	end

	def show_subscribe_form_operation do
	%Operation{
	tags: ["Remote interaction"],
	summary: "Show remote subscribe form",
	operationId: "UtilController.show_subscribe_form",
	parameters: [],
	responses: %{200 => Operation.response("Web Page", "test/html", %Schema{type: :string})}
	}
	end

	defp delete_account_request do
	%Schema{
	title: "AccountDeleteRequest",
	description: "POST body for deleting one's own account",
	type: :object,
	properties: %{
	password: %Schema{
	type: :string,
	description: "The user's own password for confirmation.",
	format: :password
	}
	},
	example: %{
	"password" => "prettyp0ony1313"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/user_import_operation.ex b/lib/pleroma/web/api_spec/operations/user_import_operation.ex
	index e99e6e648..d12ebd968 100644
	--- a/lib/pleroma/web/api_spec/operations/user_import_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/user_import_operation.ex
	@@ -1,81 +1,81 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.UserImportOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

	@spec open_api_operation(atom) :: Operation.t()
	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def follow_operation do
	%Operation{
	tags: ["Data import"],
	summary: "Import follows",
	operationId: "UserImportController.follow",
	requestBody: request_body("Parameters", import_request(), required: true),
	responses: %{
	200 => ok_response(),
	403 => Operation.response("Error", "application/json", ApiError),
	500 => Operation.response("Error", "application/json", ApiError)
	},
	security: [%{"oAuth" => ["write:follow"]}]
	}
	end

	def blocks_operation do
	%Operation{
	tags: ["Data import"],
	summary: "Import blocks",
	operationId: "UserImportController.blocks",
	requestBody: request_body("Parameters", import_request(), required: true),
	responses: %{
	200 => ok_response(),
	500 => Operation.response("Error", "application/json", ApiError)
	},
	security: [%{"oAuth" => ["write:blocks"]}]
	}
	end

	def mutes_operation do
	%Operation{
	tags: ["Data import"],
	summary: "Import mutes",
	operationId: "UserImportController.mutes",
	requestBody: request_body("Parameters", import_request(), required: true),
	responses: %{
	200 => ok_response(),
	500 => Operation.response("Error", "application/json", ApiError)
	},
	security: [%{"oAuth" => ["write:mutes"]}]
	}
	end

	defp import_request do
	%Schema{
	type: :object,
	- required: [:list],
	+ required: ["list"],
	properties: %{
	- list: %Schema{
	+ "list" => %Schema{
	description:
	"STRING or FILE containing a whitespace-separated list of accounts to import.",
	anyOf: [
	%Schema{type: :string, format: :binary},
	%Schema{type: :string}
	]
	}
	}
	}
	end

	defp ok_response do
	Operation.response("Ok", "application/json", %Schema{type: :string, example: "ok"})
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	index 1b5de4b45..fdf9d2dfb 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	@@ -1,593 +1,593 @@
	# 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.AccountController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [
	add_link_headers: 2,
	assign_account_by_id: 2,
	embed_relationships?: 1,
	json_response: 3
	]

	alias Pleroma.Maps
	alias Pleroma.User
	alias Pleroma.UserNote
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.ListView
	alias Pleroma.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.MastodonAPI.MastodonAPIController
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.OAuth.OAuthController
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.Utils.Params

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(:skip_auth when action in [:create, :lookup])

	plug(:skip_public_check when action in [:show, :statuses])

	plug(
	OAuthScopesPlug,
	%{fallback: :proceed_unauthenticated, scopes: ["read:accounts"]}
	when action in [:show, :followers, :following]
	)

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

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

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:accounts"]}
	when action in [:update_credentials, :note, :endorse, :unendorse]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:lists"]} when action == :lists)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "read:blocks"]} when action == :blocks
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:blocks"]} when action in [:block, :unblock]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:follows"]} when action == :relationships)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:follows"]}
	when action in [:follow_by_uri, :follow, :unfollow, :remove_from_followers]
	)

	plug(OAuthScopesPlug, %{scopes: ["follow", "read:mutes"]} when action == :mutes)

	plug(OAuthScopesPlug, %{scopes: ["follow", "write:mutes"]} when action in [:mute, :unmute])

	@relationship_actions [:follow, :unfollow, :remove_from_followers]
	@needs_account ~W(
	followers following lists follow unfollow mute unmute block unblock
	note endorse unendorse remove_from_followers
	)a

	plug(
	RateLimiter,
	[name: :relation_id_action, params: [:id, :uri]] when action in @relationship_actions
	)

	plug(RateLimiter, [name: :relations_actions] when action in @relationship_actions)
	plug(RateLimiter, [name: :app_account_creation] when action == :create)
	plug(:assign_account_by_id when action in @needs_account)

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

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

	@doc "POST /api/v1/accounts"
	def create(%{assigns: %{app: app}, body_params: params} = conn, _params) do
	with :ok <- validate_email_param(params),
	:ok <- TwitterAPI.validate_captcha(app, params),
	{:ok, user} <- TwitterAPI.register_user(params),
	{_, {:ok, token}} <-
	{:login, OAuthController.login(user, app, app.scopes)} do
	OAuthController.after_token_exchange(conn, %{user: user, token: token})
	else
	{:login, {:account_status, :confirmation_pending}} ->
	json_response(conn, :ok, %{
	message: "You have been registered. Please check your email for further instructions.",
	identifier: "missing_confirmed_email"
	})

	{:login, {:account_status, :approval_pending}} ->
	json_response(conn, :ok, %{
	message:
	"You have been registered. You'll be able to log in once your account is approved.",
	identifier: "awaiting_approval"
	})

	{:login, _} ->
	json_response(conn, :ok, %{
	message:
	"You have been registered. Some post-registration steps may be pending. " <>
	"Please log in manually.",
	identifier: "manual_login_required"
	})

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

	def create(%{assigns: %{app: _app}} = conn, _) do
	render_error(conn, :bad_request, "Missing parameters")
	end

	def create(conn, _) do
	render_error(conn, :forbidden, "Invalid credentials")
	end

	defp validate_email_param(%{email: email}) when not is_nil(email), do: :ok

	defp validate_email_param(_) do
	case Pleroma.Config.get([:instance, :account_activation_required]) do
	true -> {:error, dgettext("errors", "Missing parameter: %{name}", name: "email")}
	_ -> :ok
	end
	end

	@doc "GET /api/v1/accounts/verify_credentials"
	def verify_credentials(%{assigns: %{user: user}} = conn, _) do
	chat_token = Phoenix.Token.sign(conn, "user socket", user.id)

	render(conn, "show.json",
	user: user,
	for: user,
	with_pleroma_settings: true,
	with_chat_token: chat_token
	)
	end

	@doc "PATCH /api/v1/accounts/update_credentials"
	def update_credentials(%{assigns: %{user: user}, body_params: params} = conn, _params) do
	params =
	params
	\|> Enum.filter(fn {_, value} -> not is_nil(value) end)
	\|> Enum.into(%{})

	# We use an empty string as a special value to reset
	# avatars, banners, backgrounds
	user_image_value = fn
	"" -> {:ok, nil}
	value -> {:ok, value}
	end

	user_params =
	[
	:no_rich_text,
	:hide_followers_count,
	:hide_follows_count,
	:hide_followers,
	:hide_follows,
	:hide_favorites,
	:show_role,
	:skip_thread_containment,
	:allow_following_move,
	:also_known_as,
	:accepts_chat_messages,
	:show_birthday
	]
	\|> Enum.reduce(%{}, fn key, acc ->
	Maps.put_if_present(acc, key, params[key], &{:ok, Params.truthy_param?(&1)})
	end)
	\|> Maps.put_if_present(:name, params[:display_name])
	\|> Maps.put_if_present(:bio, params[:note])
	\|> Maps.put_if_present(:raw_bio, params[:note])
	\|> Maps.put_if_present(:avatar, params[:avatar], user_image_value)
	\|> Maps.put_if_present(:banner, params[:header], user_image_value)
	\|> Maps.put_if_present(:background, params[:pleroma_background_image], user_image_value)
	\|> Maps.put_if_present(
	:raw_fields,
	params[:fields_attributes],
	&{:ok, normalize_fields_attributes(&1)}
	)
	\|> Maps.put_if_present(:pleroma_settings_store, params[:pleroma_settings_store])
	\|> Maps.put_if_present(:default_scope, params[:default_scope])
	\|> Maps.put_if_present(:default_scope, params["source"]["privacy"])
	\|> Maps.put_if_present(:actor_type, params[:bot], fn bot ->
	if bot, do: {:ok, "Service"}, else: {:ok, "Person"}
	end)
	\|> Maps.put_if_present(:actor_type, params[:actor_type])
	\|> Maps.put_if_present(:also_known_as, params[:also_known_as])
	# Note: param name is indeed :locked (not an error)
	\|> Maps.put_if_present(:is_locked, params[:locked])
	# Note: param name is indeed :discoverable (not an error)
	\|> Maps.put_if_present(:is_discoverable, params[:discoverable])
	\|> Maps.put_if_present(:birthday, params[:birthday])
	\|> Maps.put_if_present(:language, Pleroma.Web.Gettext.normalize_locale(params[:language]))

	# What happens here:
	#
	# We want to update the user through the pipeline, but the ActivityPub
	# update information is not quite enough for this, because this also
	# contains local settings that don't federate and don't even appear
	# in the Update activity.
	#
	# So we first build the normal local changeset, then apply it to the
	# user data, but don't persist it. With this, we generate the object
	# data for our update activity. We feed this and the changeset as meta
	# information into the pipeline, where they will be properly updated and
	# federated.
	with changeset <- User.update_changeset(user, user_params),
	{:ok, unpersisted_user} <- Ecto.Changeset.apply_action(changeset, :update),
	updated_object <-
	Pleroma.Web.ActivityPub.UserView.render("user.json", user: unpersisted_user)
	\|> Map.delete("@context"),
	{:ok, update_data, []} <- Builder.update(user, updated_object),
	{:ok, _update, _} <-
	Pipeline.common_pipeline(update_data,
	local: true,
	user_update_changeset: changeset
	) do
	render(conn, "show.json",
	user: unpersisted_user,
	for: unpersisted_user,
	with_pleroma_settings: true
	)
	else
	{:error, %Ecto.Changeset{errors: [avatar: {"file is too large", _}]}} ->
	render_error(conn, :request_entity_too_large, "File is too large")

	{:error, %Ecto.Changeset{errors: [banner: {"file is too large", _}]}} ->
	render_error(conn, :request_entity_too_large, "File is too large")

	{:error, %Ecto.Changeset{errors: [background: {"file is too large", _}]}} ->
	render_error(conn, :request_entity_too_large, "File is too large")

	{:error, %Ecto.Changeset{errors: [{:bio, {_, _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "Bio is too long")

	{:error, %Ecto.Changeset{errors: [{:name, {_, _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "Name is too long")

	{:error, %Ecto.Changeset{errors: [{:fields, {"invalid", _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "One or more field entries are too long")

	{:error, %Ecto.Changeset{errors: [{:fields, {_, _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "Too many field entries")

	_e ->
	render_error(conn, :forbidden, "Invalid request")
	end
	end

	defp normalize_fields_attributes(fields) do
	if(Enum.all?(fields, &is_tuple/1), do: Enum.map(fields, fn {_, v} -> v end), else: fields)
	\|> Enum.map(fn
	%{} = field -> %{"name" => field.name, "value" => field.value}
	field -> field
	end)
	end

	@doc "GET /api/v1/accounts/relationships"
	def relationships(%{assigns: %{user: user}} = conn, %{id: id}) do
	targets = User.get_all_by_ids(List.wrap(id))

	render(conn, "relationships.json", user: user, targets: targets)
	end

	# Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
	def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, [])

	@doc "GET /api/v1/accounts/:id"
	def show(%{assigns: %{user: for_user}} = conn, %{id: nickname_or_id} = params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id, for: for_user),
	:visible <- User.visible_for(user, for_user) do
	render(conn, "show.json",
	user: user,
	for: for_user,
	embed_relationships: embed_relationships?(params)
	)
	else
	error -> user_visibility_error(conn, error)
	end
	end

	@doc "GET /api/v1/accounts/:id/statuses"
	def statuses(%{assigns: %{user: reading_user}} = conn, params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(params.id, for: reading_user),
	:visible <- User.visible_for(user, reading_user) do
	params =
	params
	\|> Map.delete(:tagged)
	\|> Map.put(:tag, params[:tagged])

	activities = ActivityPub.fetch_user_activities(user, reading_user, params)

	conn
	\|> add_link_headers(activities)
	\|> put_view(StatusView)
	\|> render("index.json",
	activities: activities,
	for: reading_user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	error -> user_visibility_error(conn, error)
	end
	end

	defp user_visibility_error(conn, error) do
	case error do
	:restrict_unauthenticated ->
	render_error(conn, :unauthorized, "This API requires an authenticated user")

	_ ->
	render_error(conn, :not_found, "Can't find user")
	end
	end

	@doc "GET /api/v1/accounts/:id/followers"
	def followers(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Enum.map(fn {key, value} -> {to_string(key), value} end)
	\|> Enum.into(%{})

	followers =
	cond do
	for_user && user.id == for_user.id -> MastodonAPI.get_followers(user, params)
	user.hide_followers -> []
	true -> MastodonAPI.get_followers(user, params)
	end

	conn
	\|> add_link_headers(followers)
	# https://git.pleroma.social/pleroma/pleroma-fe/-/issues/838#note_59223
	\|> render("index.json",
	for: for_user,
	users: followers,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/accounts/:id/following"
	def following(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Enum.map(fn {key, value} -> {to_string(key), value} end)
	\|> Enum.into(%{})

	followers =
	cond do
	for_user && user.id == for_user.id -> MastodonAPI.get_friends(user, params)
	user.hide_follows -> []
	true -> MastodonAPI.get_friends(user, params)
	end

	conn
	\|> add_link_headers(followers)
	# https://git.pleroma.social/pleroma/pleroma-fe/-/issues/838#note_59223
	\|> render("index.json",
	for: for_user,
	users: followers,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/accounts/:id/lists"
	def lists(%{assigns: %{user: user, account: account}} = conn, _params) do
	lists = Pleroma.List.get_lists_account_belongs(user, account)

	conn
	\|> put_view(ListView)
	\|> render("index.json", lists: lists)
	end

	@doc "POST /api/v1/accounts/:id/follow"
	def follow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not follow yourself"}
	end

	def follow(%{body_params: params, assigns: %{user: follower, account: followed}} = conn, _) do
	with {:ok, follower} <- MastodonAPI.follow(follower, followed, params) do
	render(conn, "relationship.json", user: follower, target: followed)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unfollow"
	def unfollow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not unfollow yourself"}
	end

	def unfollow(%{assigns: %{user: follower, account: followed}} = conn, _params) do
	with {:ok, follower} <- CommonAPI.unfollow(follower, followed) do
	render(conn, "relationship.json", user: follower, target: followed)
	end
	end

	@doc "POST /api/v1/accounts/:id/mute"
	def mute(%{assigns: %{user: muter, account: muted}, body_params: params} = conn, _params) do
	params =
	params
	\|> Map.put_new(:duration, Map.get(params, :expires_in, 0))

	with {:ok, _user_relationships} <- User.mute(muter, muted, params) do
	render(conn, "relationship.json", user: muter, target: muted)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unmute"
	def unmute(%{assigns: %{user: muter, account: muted}} = conn, _params) do
	with {:ok, _user_relationships} <- User.unmute(muter, muted) do
	render(conn, "relationship.json", user: muter, target: muted)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/block"
	def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
	with {:ok, _activity} <- CommonAPI.block(blocker, blocked) do
	render(conn, "relationship.json", user: blocker, target: blocked)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unblock"
	def unblock(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
	with {:ok, _activity} <- CommonAPI.unblock(blocker, blocked) do
	render(conn, "relationship.json", user: blocker, target: blocked)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/note"
	def note(
	- %{assigns: %{user: noter, account: target}, body_params: %{comment: comment}} = conn,
	+ %{assigns: %{user: noter, account: target}, body_params: %{"comment" => comment}} = conn,
	_params
	) do
	with {:ok, _user_note} <- UserNote.create(noter, target, comment) do
	render(conn, "relationship.json", user: noter, target: target)
	end
	end

	@doc "POST /api/v1/accounts/:id/pin"
	def endorse(%{assigns: %{user: endorser, account: endorsed}} = conn, _params) do
	with {:ok, _user_relationships} <- User.endorse(endorser, endorsed) do
	render(conn, "relationship.json", user: endorser, target: endorsed)
	else
	{:error, message} -> json_response(conn, :bad_request, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unpin"
	def unendorse(%{assigns: %{user: endorser, account: endorsed}} = conn, _params) do
	with {:ok, _user_relationships} <- User.unendorse(endorser, endorsed) do
	render(conn, "relationship.json", user: endorser, target: endorsed)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/remove_from_followers"
	def remove_from_followers(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not unfollow yourself"}
	end

	def remove_from_followers(%{assigns: %{user: followed, account: follower}} = conn, _params) do
	with {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
	render(conn, "relationship.json", user: followed, target: follower)
	else
	nil ->
	render_error(conn, :not_found, "Record not found")
	end
	end

	@doc "POST /api/v1/follows"
	- def follow_by_uri(%{body_params: %{uri: uri}} = conn, _) do
	+ def follow_by_uri(%{body_params: %{"uri" => uri}} = conn, _) do
	case User.get_cached_by_nickname(uri) do
	%User{} = user ->
	conn
	\|> assign(:account, user)
	\|> follow(%{})

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

	@doc "GET /api/v1/mutes"
	def mutes(%{assigns: %{user: user}} = conn, params) do
	users =
	user
	\|> User.muted_users_relation(_restrict_deactivated = true)
	\|> Pleroma.Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(users)
	\|> render("index.json",
	users: users,
	for: user,
	as: :user,
	embed_relationships: embed_relationships?(params),
	mutes: true
	)
	end

	@doc "GET /api/v1/blocks"
	def blocks(%{assigns: %{user: user}} = conn, params) do
	users =
	user
	\|> User.blocked_users_relation(_restrict_deactivated = true)
	\|> Pleroma.Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(users)
	\|> render("index.json",
	users: users,
	for: user,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/accounts/lookup"
	def lookup(conn, %{acct: nickname} = _params) do
	with %User{} = user <- User.get_by_nickname(nickname) do
	render(conn, "show.json",
	user: user,
	skip_visibility_check: true
	)
	else
	error -> user_visibility_error(conn, error)
	end
	end

	@doc "GET /api/v1/endorsements"
	def endorsements(%{assigns: %{user: user}} = conn, params) do
	users =
	user
	\|> User.endorsed_users_relation(_restrict_deactivated = true)
	\|> Pleroma.Repo.all()

	conn
	\|> render("index.json",
	users: users,
	for: user,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/identity_proofs"
	def identity_proofs(conn, params), do: MastodonAPIController.empty_array(conn, params)
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/directory_controller.ex b/lib/pleroma/web/mastodon_api/controllers/directory_controller.ex
	index 253f06cfb..f89425966 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/directory_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/directory_controller.ex
	@@ -1,82 +1,82 @@
	# 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.DirectoryController do
	use Pleroma.Web, :controller

	import Ecto.Query
	alias Pleroma.Pagination
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.MastodonAPI.AccountView

	require Logger

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	- plug(:skip_auth when action == "index")
	+ plug(:skip_auth when action == :index)

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

	@doc "GET /api/v1/directory"
	def index(%{assigns: %{user: user}} = conn, params) do
	with true <- Pleroma.Config.get([:instance, :profile_directory]) do
	limit = Map.get(params, :limit, 20) \|> min(80)

	users =
	User.Query.build(%{is_discoverable: true, invisible: false, limit: limit})
	\|> order_by_creation_date(params)
	\|> exclude_remote(params)
	\|> exclude_user(user)
	\|> exclude_relationships(user, [:block, :mute])
	\|> Pagination.fetch_paginated(params, :offset)

	conn
	\|> put_view(AccountView)
	\|> render("index.json", for: user, users: users, as: :user)
	else
	_ -> json(conn, [])
	end
	end

	defp order_by_creation_date(query, %{order: "new"}) do
	query
	end

	defp order_by_creation_date(query, _params) do
	query
	\|> order_by([u], desc_nulls_last: u.last_status_at)
	end

	defp exclude_remote(query, %{local: true}) do
	where(query, [u], u.local == true)
	end

	defp exclude_remote(query, _params) do
	query
	end

	defp exclude_user(query, %User{id: user_id}) do
	where(query, [u], u.id != ^user_id)
	end

	defp exclude_user(query, _user) do
	query
	end

	defp exclude_relationships(query, %User{id: user_id}, relationship_types) do
	query
	\|> join(:left, [u], r in UserRelationship,
	as: :user_relationships,
	on:
	r.target_id == u.id and r.source_id == ^user_id and
	r.relationship_type in ^relationship_types
	)
	\|> where([user_relationships: r], is_nil(r.target_id))
	end

	defp exclude_relationships(query, _user, _relationship_types) do
	query
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/chat_controller.ex b/lib/pleroma/web/pleroma_api/controllers/chat_controller.ex
	index 3d7b6a4a7..dc0f2cfe3 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/chat_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/chat_controller.ex
	@@ -1,188 +1,193 @@
	# 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.ChatController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Object
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	import Ecto.Query

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:chats"]}
	when action in [
	:post_chat_message,
	:create,
	:mark_as_read,
	:mark_message_as_read,
	:delete_message
	]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:chats"]} when action in [:messages, :index, :index2, :show]
	)

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

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

	def delete_message(%{assigns: %{user: %{id: user_id} = user}} = conn, %{
	message_id: message_id,
	id: chat_id
	}) do
	with %MessageReference{} = cm_ref <-
	MessageReference.get_by_id(message_id),
	^chat_id <- to_string(cm_ref.chat_id),
	%Chat{user_id: ^user_id} <- Chat.get_by_id(chat_id),
	{:ok, _} <- remove_or_delete(cm_ref, user) do
	conn
	\|> put_view(MessageReferenceView)
	\|> render("show.json", chat_message_reference: cm_ref)
	else
	_e ->
	{:error, :could_not_delete}
	end
	end

	defp remove_or_delete(
	%{object: %{data: %{"actor" => actor, "id" => id}}},
	%{ap_id: actor} = user
	) do
	with %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	CommonAPI.delete(activity.id, user)
	end
	end

	defp remove_or_delete(cm_ref, _), do: MessageReference.delete(cm_ref)

	def post_chat_message(
	%{body_params: params, assigns: %{user: user}} = conn,
	%{id: id}
	) do
	with {:ok, chat} <- Chat.get_by_user_and_id(user, id),
	- %User{} = recipient <- User.get_cached_by_ap_id(chat.recipient),
	+ {_, %User{} = recipient} <- {:user, User.get_cached_by_ap_id(chat.recipient)},
	{:ok, activity} <-
	CommonAPI.post_chat_message(user, recipient, params[:content],
	media_id: params[:media_id],
	idempotency_key: idempotency_key(conn)
	),
	message <- Object.normalize(activity, fetch: false),
	cm_ref <- MessageReference.for_chat_and_object(chat, message) do
	conn
	\|> put_view(MessageReferenceView)
	\|> render("show.json", chat_message_reference: cm_ref)
	else
	{:reject, message} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})

	{:error, message} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: message})
	+
	+ {:user, nil} ->
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: "Recipient does not exist"})
	end
	end

	def mark_message_as_read(
	%{assigns: %{user: %{id: user_id}}} = conn,
	%{id: chat_id, message_id: message_id}
	) do
	with %MessageReference{} = cm_ref <- MessageReference.get_by_id(message_id),
	^chat_id <- to_string(cm_ref.chat_id),
	%Chat{user_id: ^user_id} <- Chat.get_by_id(chat_id),
	{:ok, cm_ref} <- MessageReference.mark_as_read(cm_ref) do
	conn
	\|> put_view(MessageReferenceView)
	\|> render("show.json", chat_message_reference: cm_ref)
	end
	end

	def mark_as_read(
	- %{body_params: %{last_read_id: last_read_id}, assigns: %{user: user}} = conn,
	+ %{body_params: %{"last_read_id" => last_read_id}, assigns: %{user: user}} = conn,
	%{id: id}
	) do
	with {:ok, chat} <- Chat.get_by_user_and_id(user, id),
	{_n, _} <- MessageReference.set_all_seen_for_chat(chat, last_read_id) do
	render(conn, "show.json", chat: chat)
	end
	end

	def messages(%{assigns: %{user: user}} = conn, %{id: id} = params) do
	with {:ok, chat} <- Chat.get_by_user_and_id(user, id) do
	chat_message_refs =
	chat
	\|> MessageReference.for_chat_query()
	\|> Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(chat_message_refs)
	\|> put_view(MessageReferenceView)
	\|> render("index.json", chat_message_references: chat_message_refs)
	end
	end

	def index(%{assigns: %{user: user}} = conn, params) do
	chats =
	index_query(user, params)
	\|> Repo.all()

	render(conn, "index.json", chats: chats)
	end

	def index2(%{assigns: %{user: user}} = conn, params) do
	chats =
	index_query(user, params)
	\|> Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(chats)
	\|> render("index.json", chats: chats)
	end

	defp index_query(%{id: user_id} = user, params) do
	exclude_users =
	User.cached_blocked_users_ap_ids(user) ++
	if params[:with_muted], do: [], else: User.cached_muted_users_ap_ids(user)

	user_id
	\|> Chat.for_user_query()
	\|> where([c], c.recipient not in ^exclude_users)
	end

	def create(%{assigns: %{user: user}} = conn, %{id: id}) do
	with %User{ap_id: recipient} <- User.get_cached_by_id(id),
	{:ok, %Chat{} = chat} <- Chat.get_or_create(user.id, recipient) do
	render(conn, "show.json", chat: chat)
	end
	end

	def show(%{assigns: %{user: user}} = conn, %{id: id}) do
	with {:ok, chat} <- Chat.get_by_user_and_id(user, id) do
	render(conn, "show.json", chat: chat)
	end
	end

	defp idempotency_key(conn) do
	case get_req_header(conn, "idempotency-key") do
	[key] -> key
	_ -> nil
	end
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/emoji_file_controller.ex b/lib/pleroma/web/pleroma_api/controllers/emoji_file_controller.ex
	index f854cf9c1..618b924a0 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/emoji_file_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/emoji_file_controller.ex
	@@ -1,154 +1,154 @@
	# 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.EmojiFileController do
	use Pleroma.Web, :controller

	alias Pleroma.Emoji.Pack
	alias Pleroma.Web.ApiSpec

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	Pleroma.Web.Plugs.OAuthScopesPlug,
	%{scopes: ["admin:write"]}
	when action in [
	:create,
	:update,
	:delete
	]
	)

	defdelegate open_api_operation(action), to: ApiSpec.PleromaEmojiFileOperation

	def create(%{body_params: params} = conn, %{name: pack_name}) do
	- filename = params[:filename] \|\| get_filename(params[:file])
	- shortcode = params[:shortcode] \|\| Path.basename(filename, Path.extname(filename))
	+ filename = params["filename"] \|\| get_filename(params["file"])
	+ shortcode = params["shortcode"] \|\| Path.basename(filename, Path.extname(filename))

	with {:ok, pack} <- Pack.load_pack(pack_name),
	- {:ok, file} <- get_file(params[:file]),
	+ {:ok, file} <- get_file(params["file"]),
	{:ok, pack} <- Pack.add_file(pack, shortcode, filename, file) do
	json(conn, pack.files)
	else
	{:error, :already_exists} ->
	conn
	\|> put_status(:conflict)
	\|> json(%{error: "An emoji with the \"#{shortcode}\" shortcode already exists"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: "pack name, shortcode or filename cannot be empty"})

	{:error, _} = error ->
	handle_error(conn, error, %{
	pack_name: pack_name,
	message: "Unexpected error occurred while adding file to pack."
	})
	end
	end

	- def update(%{body_params: %{shortcode: shortcode} = params} = conn, %{name: pack_name}) do
	- new_shortcode = params[:new_shortcode]
	- new_filename = params[:new_filename]
	- force = params[:force]
	+ def update(%{body_params: %{"shortcode" => shortcode} = params} = conn, %{name: pack_name}) do
	+ new_shortcode = params["new_shortcode"]
	+ new_filename = params["new_filename"]
	+ force = params["force"]

	with {:ok, pack} <- Pack.load_pack(pack_name),
	{:ok, pack} <- Pack.update_file(pack, shortcode, new_shortcode, new_filename, force) do
	json(conn, pack.files)
	else
	{:error, :already_exists} ->
	conn
	\|> put_status(:conflict)
	\|> json(%{
	error:
	"New shortcode \"#{new_shortcode}\" is already used. If you want to override emoji use 'force' option"
	})

	{:error, :empty_values} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: "new_shortcode or new_filename cannot be empty"})

	{:error, _} = error ->
	handle_error(conn, error, %{
	pack_name: pack_name,
	code: shortcode,
	message: "Unexpected error occurred while updating."
	})
	end
	end

	def delete(conn, %{name: pack_name, shortcode: shortcode}) do
	with {:ok, pack} <- Pack.load_pack(pack_name),
	{:ok, pack} <- Pack.delete_file(pack, shortcode) do
	json(conn, pack.files)
	else
	{:error, :empty_values} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: "pack name or shortcode cannot be empty"})

	{:error, _} = error ->
	handle_error(conn, error, %{
	pack_name: pack_name,
	code: shortcode,
	message: "Unexpected error occurred while deleting emoji file."
	})
	end
	end

	defp handle_error(conn, {:error, :doesnt_exist}, %{code: emoji_code}) do
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "Emoji \"#{emoji_code}\" does not exist"})
	end

	defp handle_error(conn, {:error, :enoent}, %{pack_name: pack_name}) do
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "pack \"#{pack_name}\" is not found"})
	end

	defp handle_error(conn, {:error, error}, opts) do
	message =
	[
	Map.get(opts, :message, "Unexpected error occurred."),
	Pleroma.Utils.posix_error_message(error)
	]
	\|> Enum.join(" ")
	\|> String.trim()

	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: message})
	end

	defp get_filename(%Plug.Upload{filename: filename}), do: filename
	defp get_filename(url) when is_binary(url), do: Path.basename(url)

	- def get_file(%Plug.Upload{} = file), do: {:ok, file}
	+ defp get_file(%Plug.Upload{} = file), do: {:ok, file}

	- def get_file(url) when is_binary(url) do
	+ defp get_file(url) when is_binary(url) do
	with {:ok, %Tesla.Env{body: body, status: code, headers: headers}}
	when code in 200..299 <- Pleroma.HTTP.get(url) do
	path = Plug.Upload.random_file!("emoji")

	content_type =
	case List.keyfind(headers, "content-type", 0) do
	{"content-type", value} -> value
	nil -> nil
	end

	File.write(path, body)

	{:ok,
	%Plug.Upload{
	filename: Path.basename(url),
	path: path,
	content_type: content_type
	}}
	end
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex b/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	index 420fea12c..64fd95759 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	@@ -1,230 +1,230 @@
	# 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.EmojiPackController do
	use Pleroma.Web, :controller

	alias Pleroma.Emoji.Pack

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	Pleroma.Web.Plugs.OAuthScopesPlug,
	%{scopes: ["admin:write"]}
	when action in [
	:import_from_filesystem,
	:remote,
	:download,
	:create,
	:update,
	:delete
	]
	)

	plug(:skip_auth when action in [:index, :archive, :show])

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

	def remote(conn, params) do
	with {:ok, packs} <-
	Pack.list_remote(url: params.url, page_size: params.page_size, page: params.page) do
	json(conn, packs)
	else
	{:error, :not_shareable} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "The requested instance does not support sharing emoji packs"})
	end
	end

	def index(conn, params) do
	emoji_path =
	[:instance, :static_dir]
	\|> Pleroma.Config.get!()
	\|> Path.join("emoji")

	with {:ok, packs, count} <- Pack.list_local(page: params.page, page_size: params.page_size) do
	json(conn, %{packs: packs, count: count})
	else
	{:error, :create_dir, e} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Failed to create the emoji pack directory at #{emoji_path}: #{e}"})

	{:error, :ls, e} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{
	error: "Failed to get the contents of the emoji pack directory at #{emoji_path}: #{e}"
	})
	end
	end

	def show(conn, %{name: name, page: page, page_size: page_size}) do
	name = String.trim(name)

	with {:ok, pack} <- Pack.show(name: name, page: page, page_size: page_size) do
	json(conn, pack)
	else
	{:error, :enoent} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})

	{:error, error} ->
	error_message =
	add_posix_error(
	"Failed to get the contents of the `#{name}` pack.",
	error
	)

	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: error_message})
	end
	end

	def archive(conn, %{name: name}) do
	with {:ok, archive} <- Pack.get_archive(name) do
	send_download(conn, {:binary, archive}, filename: "#{name}.zip")
	else
	{:error, :cant_download} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{
	error:
	"Pack #{name} cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
	})

	{:error, :enoent} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})
	end
	end

	- def download(%{body_params: %{url: url, name: name} = params} = conn, _) do
	- with {:ok, _pack} <- Pack.download(name, url, params[:as]) do
	+ def download(%{body_params: %{"url" => url, "name" => name} = params} = conn, _) do
	+ with {:ok, _pack} <- Pack.download(name, url, params["as"]) do
	json(conn, "ok")
	else
	{:error, :not_shareable} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "The requested instance does not support sharing emoji packs"})

	{:error, :invalid_checksum} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "SHA256 for the pack doesn't match the one sent by the server"})

	{:error, error} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: error})
	end
	end

	def create(conn, %{name: name}) do
	name = String.trim(name)

	with {:ok, _pack} <- Pack.create(name) do
	json(conn, "ok")
	else
	{:error, :eexist} ->
	conn
	\|> put_status(:conflict)
	\|> json(%{error: "A pack named \"#{name}\" already exists"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})

	{:error, error} ->
	error_message =
	add_posix_error(
	"Unexpected error occurred while creating pack.",
	error
	)

	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: error_message})
	end
	end

	def delete(conn, %{name: name}) do
	name = String.trim(name)

	with {:ok, deleted} when deleted != [] <- Pack.delete(name) do
	json(conn, "ok")
	else
	{:ok, []} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})

	{:error, error, _} ->
	error_message = add_posix_error("Couldn't delete the `#{name}` pack", error)

	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: error_message})
	end
	end

	- def update(%{body_params: %{metadata: metadata}} = conn, %{name: name}) do
	+ def update(%{body_params: %{"metadata" => metadata}} = conn, %{name: name}) do
	with {:ok, pack} <- Pack.update_metadata(name, metadata) do
	json(conn, pack.pack)
	else
	{:error, :incomplete} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "The fallback archive does not have all files specified in pack.json"})

	{:error, error} ->
	error_message =
	add_posix_error(
	"Unexpected error occurred while updating pack metadata.",
	error
	)

	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: error_message})
	end
	end

	def import_from_filesystem(conn, _params) do
	with {:ok, names} <- Pack.import_from_filesystem() do
	json(conn, names)
	else
	{:error, :no_read_write} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Error: emoji pack directory must be writable"})

	{:error, _} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Error accessing emoji pack directory"})
	end
	end

	defp add_posix_error(msg, error) do
	[msg, Pleroma.Utils.posix_error_message(error)]
	\|> Enum.join(" ")
	\|> String.trim()
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/mascot_controller.ex b/lib/pleroma/web/pleroma_api/controllers/mascot_controller.ex
	index 66e9d8481..0533c348c 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/mascot_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/mascot_controller.ex
	@@ -1,42 +1,45 @@
	# 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.MascotController do
	use Pleroma.Web, :controller

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	plug(Majic.Plug, [pool: Pleroma.MajicPool] when action in [:update])
	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(OAuthScopesPlug, %{scopes: ["read:accounts"]} when action == :show)
	plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action != :show)

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

	@doc "GET /api/v1/pleroma/mascot"
	def show(%{assigns: %{user: user}} = conn, _params) do
	json(conn, User.get_mascot(user))
	end

	@doc "PUT /api/v1/pleroma/mascot"
	- def update(%{assigns: %{user: user}, body_params: %{file: file}} = conn, _) do
	- with {:content_type, "image" <> _} <- {:content_type, file.content_type},
	- {:ok, object} <- ActivityPub.upload(file, actor: User.ap_id(user)) do
	+ def update(%{assigns: %{user: user}, body_params: %{"file" => file}} = conn, _) do
	+ with {_, "image" <> _} <- {:content_type, file.content_type},
	+ {_, {:ok, object}} <- {:upload, ActivityPub.upload(file, actor: User.ap_id(user))} do
	attachment = render_attachment(object)
	{:ok, _user} = User.mascot_update(user, attachment)

	json(conn, attachment)
	else
	{:content_type, _} ->
	render_error(conn, :unsupported_media_type, "mascots can only be images")
	+
	+ {:upload, {:error, _}} ->
	+ render_error(conn, :error, "error uploading file")
	end
	end

	defp render_attachment(object) do
	attachment_data = Map.put(object.data, "id", object.id)
	Pleroma.Web.MastodonAPI.StatusView.render("attachment.json", %{attachment: attachment_data})
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/notification_controller.ex b/lib/pleroma/web/pleroma_api/controllers/notification_controller.ex
	index 87ea81cef..0c6ec29f5 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/notification_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/notification_controller.ex
	@@ -1,38 +1,38 @@
	# 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.NotificationController do
	use Pleroma.Web, :controller

	alias Pleroma.Notification

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	Pleroma.Web.Plugs.OAuthScopesPlug,
	%{scopes: ["write:notifications"]} when action == :mark_as_read
	)

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

	- def mark_as_read(%{assigns: %{user: user}, body_params: %{id: notification_id}} = conn, _) do
	+ def mark_as_read(%{assigns: %{user: user}, body_params: %{"id" => notification_id}} = conn, _) do
	with {:ok, notification} <- Notification.read_one(user, notification_id) do
	render(conn, "show.json", notification: notification, for: user)
	else
	{:error, message} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{"error" => message})
	end
	end

	- def mark_as_read(%{assigns: %{user: user}, body_params: %{max_id: max_id}} = conn, _) do
	+ def mark_as_read(%{assigns: %{user: user}, body_params: %{"max_id" => max_id}} = conn, _) do
	notifications =
	user
	\|> Notification.set_read_up_to(max_id)
	\|> Enum.take(80)

	render(conn, "index.json", notifications: notifications, for: user)
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/user_import_controller.ex b/lib/pleroma/web/pleroma_api/controllers/user_import_controller.ex
	index 90428a532..d0ae6d6e5 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/user_import_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/user_import_controller.ex
	@@ -1,61 +1,61 @@
	# 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.UserImportController do
	use Pleroma.Web, :controller

	require Logger

	alias Pleroma.User
	alias Pleroma.Web.ApiSpec
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	plug(OAuthScopesPlug, %{scopes: ["follow", "write:follows"]} when action == :follow)
	plug(OAuthScopesPlug, %{scopes: ["follow", "write:blocks"]} when action == :blocks)
	plug(OAuthScopesPlug, %{scopes: ["follow", "write:mutes"]} when action == :mutes)

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	defdelegate open_api_operation(action), to: ApiSpec.UserImportOperation

	- def follow(%{body_params: %{list: %Plug.Upload{path: path}}} = conn, _) do
	- follow(%Plug.Conn{conn \| body_params: %{list: File.read!(path)}}, %{})
	+ def follow(%{body_params: %{"list" => %Plug.Upload{path: path}}} = conn, _) do
	+ follow(%Plug.Conn{conn \| body_params: %{"list" => File.read!(path)}}, %{})
	end

	- def follow(%{assigns: %{user: follower}, body_params: %{list: list}} = conn, _) do
	+ def follow(%{assigns: %{user: follower}, body_params: %{"list" => list}} = conn, _) do
	identifiers =
	list
	\|> String.split("\n")
	\|> Enum.map(&(&1 \|> String.split(",") \|> List.first()))
	\|> List.delete("Account address")
	\|> Enum.map(&(&1 \|> String.trim() \|> String.trim_leading("@")))
	\|> Enum.reject(&(&1 == ""))

	User.Import.follow_import(follower, identifiers)
	json(conn, "job started")
	end

	- def blocks(%{body_params: %{list: %Plug.Upload{path: path}}} = conn, _) do
	- blocks(%Plug.Conn{conn \| body_params: %{list: File.read!(path)}}, %{})
	+ def blocks(%{body_params: %{"list" => %Plug.Upload{path: path}}} = conn, _) do
	+ blocks(%Plug.Conn{conn \| body_params: %{"list" => File.read!(path)}}, %{})
	end

	- def blocks(%{assigns: %{user: blocker}, body_params: %{list: list}} = conn, _) do
	+ def blocks(%{assigns: %{user: blocker}, body_params: %{"list" => list}} = conn, _) do
	User.Import.blocks_import(blocker, prepare_user_identifiers(list))
	json(conn, "job started")
	end

	- def mutes(%{body_params: %{list: %Plug.Upload{path: path}}} = conn, _) do
	- mutes(%Plug.Conn{conn \| body_params: %{list: File.read!(path)}}, %{})
	+ def mutes(%{body_params: %{"list" => %Plug.Upload{path: path}}} = conn, _) do
	+ mutes(%Plug.Conn{conn \| body_params: %{"list" => File.read!(path)}}, %{})
	end

	- def mutes(%{assigns: %{user: user}, body_params: %{list: list}} = conn, _) do
	+ def mutes(%{assigns: %{user: user}, body_params: %{"list" => list}} = conn, _) do
	User.Import.mutes_import(user, prepare_user_identifiers(list))
	json(conn, "job started")
	end

	defp prepare_user_identifiers(list) do
	list
	\|> String.split()
	\|> Enum.map(&String.trim_leading(&1, "@"))
	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 c8ecf5eff..a74c806a6 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,368 +1,371 @@
	# 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.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.WebFinger

	plug(
	Pleroma.Web.ApiSpec.CastAndValidate
	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(%{body_params: %{ap_id: ap_id, profile: profile}} = conn, _params) do
	+ def remote_interaction(
	+ %{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 ->
	Map.put(acc, code, %{image_url: file, tags: tags})
	end)

	json(conn, emoji)
	end

	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}, body_params: body_params} = conn, %{}) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, _user} <-
	User.reset_password(user, %{
	password: body_params.new_password,
	password_confirmation: body_params.new_password_confirmation
	}) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "New password #{error}."})

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

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

	def change_email(%{assigns: %{user: user}, 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}, body_params: body_params} = conn, params) 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}} = conn, params) 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}, 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}, 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}, 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/admin_api/controllers/config_controller_test.exs b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	index 19ce3681c..734aca752 100644
	--- a/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/config_controller_test.exs
	@@ -1,1526 +1,1526 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.ConfigDB

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/pleroma/admin/config" do
	setup do: clear_config(:configurable_from_database, true)

	test "when configuration from database is off", %{conn: conn} do
	clear_config(:configurable_from_database, false)
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response_and_validate_schema(conn, 400) ==
	%{
	"error" => "You must enable configurable_from_database in your config file."
	}
	end

	test "with settings only in db", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	conn = get(conn, "/api/pleroma/admin/config?only_db=true")

	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => key1,
	"value" => _
	},
	%{
	"group" => ":pleroma",
	"key" => key2,
	"value" => _
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert key1 == inspect(config1.key)
	assert key2 == inspect(config2.key)
	end

	test "db is added to settings that are in db", %{conn: conn} do
	_config = insert(:config, key: ":instance", value: [name: "Some name"])

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	[instance_config] =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key == ":instance"
	end)

	assert instance_config["db"] == [":name"]
	end

	test "merged default setting with db settings", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	config3 =
	insert(:config,
	value: [k1: :v1, k2: :v2]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert length(configs) > 3

	saved_configs = [config1, config2, config3]
	keys = Enum.map(saved_configs, &inspect(&1.key))

	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in keys
	end)

	assert length(received_configs) == 3

	db_keys =
	config3.value
	\|> Keyword.keys()
	\|> ConfigDB.to_json_types()

	keys = Enum.map(saved_configs -- [config3], &inspect(&1.key))

	values = Enum.map(saved_configs, &ConfigDB.to_json_types(&1.value))

	mapset_keys = MapSet.new(keys ++ db_keys)

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	db = MapSet.new(db)
	assert MapSet.subset?(db, mapset_keys)

	assert value in values
	end)
	end

	test "subkeys with full update right merge", %{conn: conn} do
	insert(:config,
	key: ":emoji",
	value: [groups: [a: 1, b: 2], key: [a: 1]]
	)

	insert(:config,
	key: ":assets",
	value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	vals =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in [":emoji", ":assets"]
	end)

	emoji = Enum.find(vals, fn %{"key" => key} -> key == ":emoji" end)
	assets = Enum.find(vals, fn %{"key" => key} -> key == ":assets" end)

	emoji_val = ConfigDB.to_elixir_types(emoji["value"])
	assets_val = ConfigDB.to_elixir_types(assets["value"])

	assert emoji_val[:groups] == [a: 1, b: 2]
	assert assets_val[:mascots] == [a: 1, b: 2]
	end

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:admin_token], "password123")

	build_conn()
	\|> get("/api/pleroma/admin/config?admin_token=password123")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "POST /api/pleroma/admin/config with configdb disabled", %{conn: conn} do
	clear_config(:configurable_from_database, false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => []})

	assert json_response_and_validate_schema(conn, 400) ==
	%{"error" => "You must enable configurable_from_database in your config file."}
	end

	describe "POST /api/pleroma/admin/config" do
	setup do
	http = Application.get_env(:pleroma, :http)

	on_exit(fn ->
	Application.delete_env(:pleroma, :key1)
	Application.delete_env(:pleroma, :key2)
	Application.delete_env(:pleroma, :key3)
	Application.delete_env(:pleroma, :key4)
	Application.delete_env(:pleroma, :keyaa1)
	Application.delete_env(:pleroma, :keyaa2)
	Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
	Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
	Application.put_env(:pleroma, :http, http)
	Application.put_env(:tesla, :adapter, Tesla.Mock)
	Restarter.Pleroma.refresh()
	end)
	end

	setup do: clear_config(:configurable_from_database, true)

	@tag capture_log: true
	test "create new config setting in db", %{conn: conn} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	on_exit(fn -> Application.put_env(:ueberauth, Ueberauth, ueberauth) end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
	},
	%{
	group: ":pleroma",
	key: ":key2",
	value: %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	}
	},
	%{
	group: ":pleroma",
	key: ":key3",
	value: [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	group: ":pleroma",
	key: ":key4",
	value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
	},
	%{
	group: ":idna",
	key: ":key5",
	value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => "value1",
	"db" => [":key1"]
	},
	%{
	"group" => ":ueberauth",
	"key" => "Ueberauth",
	"value" => [%{"tuple" => [":consumer_secret", "aaaa"]}],
	"db" => [":consumer_secret"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key2",
	"value" => %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	},
	"db" => [":key2"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key3",
	"value" => [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	],
	"db" => [":key3"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key4",
	"value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"},
	"db" => [":key4"]
	},
	%{
	"group" => ":idna",
	"key" => ":key5",
	"value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]},
	"db" => [":key5"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == "value1"

	assert Application.get_env(:pleroma, :key2) == %{
	nested_1: "nested_value1",
	nested_2: [
	%{nested_22: "nested_value222"},
	%{nested_33: %{nested_44: "nested_444"}}
	]
	}

	assert Application.get_env(:pleroma, :key3) == [
	%{"nested_3" => :nested_3, "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]

	assert Application.get_env(:pleroma, :key4) == %{
	"endpoint" => "https://example.com",
	nested_5: :upload
	}

	assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
	end

	@tag capture_log: true
	test "save configs setting without explicit key", %{conn: conn} do
	adapter = Application.get_env(:http, :adapter)
	send_user_agent = Application.get_env(:http, :send_user_agent)
	user_agent = Application.get_env(:http, :user_agent)

	on_exit(fn ->
	Application.put_env(:http, :adapter, adapter)
	Application.put_env(:http, :send_user_agent, send_user_agent)
	Application.put_env(:http, :user_agent, user_agent)
	end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":http",
	key: ":adapter",
	value: [":someval"]
	},
	%{
	group: ":http",
	key: ":send_user_agent",
	value: true
	},
	%{
	group: ":http",
	key: ":user_agent",
	value: [":default"]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":http",
	"key" => ":adapter",
	"value" => [":someval"],
	"db" => [":adapter"]
	},
	%{
	"group" => ":http",
	"key" => ":send_user_agent",
	"value" => true,
	"db" => [":send_user_agent"]
	},
	%{
	"group" => ":http",
	"key" => ":user_agent",
	"value" => [":default"],
	"db" => [":user_agent"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:http, :adapter) == [:someval]
	assert Application.get_env(:http, :send_user_agent) == true
	assert Application.get_env(:http, :user_agent) == [:default]
	end

	test "saving config with partial update", %{conn: conn} do
	insert(:config, key: ":key1", value: :erlang.term_to_binary(key1: 1, key2: 2))

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key2", 2]},
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key1", ":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving config which need pleroma reboot", %{conn: conn} do
	clear_config([:shout, :enabled], true)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":shout", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":shout",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"]

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "update setting which need reboot, don't change reboot flag until reboot", %{conn: conn} do
	clear_config([:shout, :enabled], true)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":shout", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":shout",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key3"]
	}
	],
	"need_reboot" => true
	}

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "saving config with nested merge", %{conn: conn} do
	insert(:config, key: :key1, value: [key1: 1, key2: [k1: 1, k2: 2]])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":key1",
	value: [
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k1", 1]},
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	],
	"db" => [":key1", ":key3", ":key2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving special atoms", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	],
	"db" => [":ssl_options"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == [
	ssl_options: [versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]]
	]
	end

	test "saving full setting if value is in full_key_update list", %{conn: conn} do
	backends = Application.get_env(:logger, :backends)
	on_exit(fn -> Application.put_env(:logger, :backends, backends) end)

	insert(:config,
	group: :logger,
	key: :backends,
	value: []
	)

	Pleroma.Config.TransferTask.load_and_update_env([], false)

	assert Application.get_env(:logger, :backends) == []

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":logger",
	key: ":backends",
	value: [":console"]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":logger",
	"key" => ":backends",
	"value" => [
	":console"
	],
	"db" => [":backends"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:logger, :backends) == [
	:console
	]
	end

	test "saving full setting if value is not keyword", %{conn: conn} do
	insert(:config,
	group: :tesla,
	key: :adapter,
	value: Tesla.Adapter.Hackey
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":tesla", key: ":adapter", value: "Tesla.Adapter.Httpc"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":tesla",
	"key" => ":adapter",
	"value" => "Tesla.Adapter.Httpc",
	"db" => [":adapter"]
	}
	],
	"need_reboot" => false
	}
	end

	test "update config setting & delete with fallback to default value", %{
	conn: conn,
	admin: admin,
	token: token
	} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	insert(:config, key: :keyaa1)
	insert(:config, key: :keyaa2)

	config3 =
	insert(:config,
	group: :ueberauth,
	key: Ueberauth
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa1", value: "another_value"},
	%{group: ":pleroma", key: ":keyaa2", value: "another_value"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => "another_value",
	"db" => [":keyaa1"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":keyaa2",
	"value" => "another_value",
	"db" => [":keyaa2"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	assert Application.get_env(:pleroma, :keyaa2) == "another_value"
	assert Application.get_env(:ueberauth, Ueberauth) == config3.value

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa2", delete: true},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [],
	"need_reboot" => false
	}

	assert Application.get_env(:ueberauth, Ueberauth) == ueberauth
	refute Keyword.has_key?(Application.get_all_env(:pleroma), :keyaa2)
	end

	test "common config example", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	]
	}
	]
	})

	assert Config.get([Pleroma.Captcha.NotReal, :name]) == "Pleroma"

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	],
	"db" => [
	":enabled",
	":method",
	":seconds_valid",
	":path",
	":key1",
	":partial_chain",
	":regex1",
	":regex2",
	":regex3",
	":regex4",
	":name"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "tuples with more than two values", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	- "Phoenix.Endpoint.Cowboy2Handler",
	+ "Plug.Cowboy.Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	- "Phoenix.Endpoint.Cowboy2Handler",
	+ "Plug.Cowboy.Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	],
	"db" => [":http"]
	}
	],
	"need_reboot" => false
	}
	end

	test "settings with nesting map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000,
	"nested" => %{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000
	}
	}
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0,
	"nested" => %{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0
	}
	}
	]
	}
	],
	"db" => [":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "value as map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"},
	"db" => [":key1"]
	}
	],
	"need_reboot" => false
	}
	end

	test "queues key as atom", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	],
	"db" => [
	":federator_incoming",
	":federator_outgoing",
	":web_push",
	":mailer",
	":transmogrifier",
	":scheduled_activities",
	":background"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "delete part of settings by atom subkeys", %{conn: conn} do
	insert(:config,
	key: :keyaa1,
	value: [subkey1: "val1", subkey2: "val2", subkey3: "val3"]
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":keyaa1",
	subkeys: [":subkey1", ":subkey3"],
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => [%{"tuple" => [":subkey2", "val2"]}],
	"db" => [":subkey2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "proxy tuple localhost", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple domain", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple ip", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]} in value
	assert ":proxy_url" in db
	end

	@tag capture_log: true
	test "doesn't set keys not in the whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :key1},
	{:pleroma, :key2},
	{:pleroma, Pleroma.Captcha.NotReal},
	{:not_real}
	])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{group: ":pleroma", key: ":key2", value: "value2"},
	%{group: ":pleroma", key: ":key3", value: "value3"},
	%{group: ":pleroma", key: "Pleroma.Web.Endpoint.NotReal", value: "value4"},
	%{group: ":pleroma", key: "Pleroma.Captcha.NotReal", value: "value5"},
	%{group: ":not_real", key: ":anything", value: "value6"}
	]
	})

	assert Application.get_env(:pleroma, :key1) == "value1"
	assert Application.get_env(:pleroma, :key2) == "value2"
	assert Application.get_env(:pleroma, :key3) == nil
	assert Application.get_env(:pleroma, Pleroma.Web.Endpoint.NotReal) == nil
	assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == "value5"
	assert Application.get_env(:not_real, :anything) == "value6"
	end

	test "args for Pleroma.Upload.Filter.Mogrify with custom tuples", %{conn: conn} do
	clear_config(Pleroma.Upload.Filter.Mogrify)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	]
	}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	assert Config.get(Pleroma.Upload.Filter.Mogrify) == [args: ["auto-orient", "strip"]]

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	]
	}
	]
	})
	\|> json_response(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	assert Config.get(Pleroma.Upload.Filter.Mogrify) == [
	args: ["auto-orient", "strip", {"implode", "1"}, {"resize", "3840x1080>"}]
	]
	end

	test "enables the welcome messages", %{conn: conn} do
	clear_config([:welcome])

	params = %{
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => [
	%{
	"tuple" => [
	":direct_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":chat_message",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":message", "Welcome to Pleroma!"]},
	%{"tuple" => [":sender_nickname", "pleroma"]}
	]
	]
	},
	%{
	"tuple" => [
	":email",
	[
	%{"tuple" => [":enabled", true]},
	%{"tuple" => [":sender", %{"tuple" => ["pleroma@dev.dev", "Pleroma"]}]},
	%{"tuple" => [":subject", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":html", "Welcome to <%= instance_name %>!"]},
	%{"tuple" => [":text", "Welcome to <%= instance_name %>!"]}
	]
	]
	}
	]
	}

	refute Pleroma.User.WelcomeEmail.enabled?()
	refute Pleroma.User.WelcomeMessage.enabled?()
	refute Pleroma.User.WelcomeChatMessage.enabled?()

	res =
	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200)

	assert Pleroma.User.WelcomeEmail.enabled?()
	assert Pleroma.User.WelcomeMessage.enabled?()
	assert Pleroma.User.WelcomeChatMessage.enabled?()

	assert res == %{
	"configs" => [
	%{
	"db" => [":direct_message", ":chat_message", ":email"],
	"group" => ":pleroma",
	"key" => ":welcome",
	"value" => params["value"]
	}
	],
	"need_reboot" => false
	}
	end

	test "custom instance thumbnail", %{conn: conn} do
	clear_config([:instance])

	params = %{
	"group" => ":pleroma",
	"key" => ":instance",
	"value" => [
	%{
	"tuple" => [
	":instance_thumbnail",
	"https://example.com/media/new_thumbnail.jpg"
	]
	}
	]
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200) ==
	%{
	"configs" => [
	%{
	"db" => [":instance_thumbnail"],
	"group" => ":pleroma",
	"key" => ":instance",
	"value" => params["value"]
	}
	],
	"need_reboot" => false
	}

	assert conn
	\|> get("/api/v1/instance")
	\|> json_response_and_validate_schema(200)
	\|> Map.take(["thumbnail"]) ==
	%{"thumbnail" => "https://example.com/media/new_thumbnail.jpg"}
	end

	test "Concurrent Limiter", %{conn: conn} do
	clear_config([ConcurrentLimiter])

	params = %{
	"group" => ":pleroma",
	"key" => "ConcurrentLimiter",
	"value" => [
	%{
	"tuple" => [
	"Pleroma.Web.RichMedia.Helpers",
	[
	%{"tuple" => [":max_running", 6]},
	%{"tuple" => [":max_waiting", 6]}
	]
	]
	},
	%{
	"tuple" => [
	"Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy",
	[
	%{"tuple" => [":max_running", 7]},
	%{"tuple" => [":max_waiting", 7]}
	]
	]
	}
	]
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => [params]})
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "GET /api/pleroma/admin/config/descriptions" do
	test "structure", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	assert [child \| _others] = json_response_and_validate_schema(conn, 200)

	assert child["children"]
	assert child["key"]
	assert String.starts_with?(child["group"], ":")
	assert child["description"]
	end

	test "filters by database configuration whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :instance},
	{:pleroma, :activitypub},
	{:pleroma, Pleroma.Upload}
	])

	conn = get(conn, "/api/pleroma/admin/config/descriptions")

	children = json_response_and_validate_schema(conn, 200)

	assert length(children) == 3

	assert Enum.count(children, fn c -> c["group"] == ":pleroma" end) == 3

	instance = Enum.find(children, fn c -> c["key"] == ":instance" end)
	assert instance["children"]

	activitypub = Enum.find(children, fn c -> c["key"] == ":activitypub" end)
	assert activitypub["children"]

	web_endpoint = Enum.find(children, fn c -> c["key"] == "Pleroma.Upload" end)
	assert web_endpoint["children"]
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 10, 4:29 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1785030
Default Alt Text: (458 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions