No OneTemporary
Actions

Authored By

Unknown

Size

501 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/benchmarks/load_testing/activities.ex b/benchmarks/load_testing/activities.ex
	index f5c7bfce8..b9f6b24da 100644
	--- a/benchmarks/load_testing/activities.ex
	+++ b/benchmarks/load_testing/activities.ex
	@@ -1,595 +1,595 @@
	defmodule Pleroma.LoadTesting.Activities do
	@moduledoc """
	Module for generating different activities.
	"""
	import Ecto.Query
	import Pleroma.LoadTesting.Helper, only: [to_sec: 1]

	alias Ecto.UUID
	alias Pleroma.Constants
	alias Pleroma.LoadTesting.Users
	alias Pleroma.Repo
	alias Pleroma.Web.CommonAPI

	require Constants

	@defaults [
	iterations: 170,
	friends_used: 20,
	non_friends_used: 20
	]

	@max_concurrency 10

	@visibility ~w(public private direct unlisted)
	@types [
	:simple,
	:simple_filtered,
	:emoji,
	:mentions,
	:hell_thread,
	:attachment,
	:tag,
	:like,
	:reblog,
	:simple_thread
	]
	@groups [:friends_local, :friends_remote, :non_friends_local, :non_friends_local]
	@remote_groups [:friends_remote, :non_friends_remote]
	@friends_groups [:friends_local, :friends_remote]
	@non_friends_groups [:non_friends_local, :non_friends_remote]

	@spec generate(User.t(), keyword()) :: :ok
	def generate(user, opts \\ []) do
	{:ok, _} =
	Agent.start_link(fn -> %{} end,
	name: :benchmark_state
	)

	opts = Keyword.merge(@defaults, opts)

	users = Users.prepare_users(user, opts)

	{:ok, _} = Agent.start_link(fn -> users[:non_friends_remote] end, name: :non_friends_remote)

	task_data =
	for visibility <- @visibility,
	type <- @types,
	group <- [:user \| @groups],
	do: {visibility, type, group}

	IO.puts("Starting generating #{opts[:iterations]} iterations of activities...")

	public_long_thread = fn ->
	generate_long_thread("public", users, opts)
	end

	private_long_thread = fn ->
	generate_long_thread("private", users, opts)
	end

	iterations = opts[:iterations]

	{time, _} =
	:timer.tc(fn ->
	Enum.each(
	1..iterations,
	fn
	i when i == iterations - 2 ->
	spawn(public_long_thread)
	spawn(private_long_thread)
	generate_activities(users, Enum.shuffle(task_data), opts)

	_ ->
	generate_activities(users, Enum.shuffle(task_data), opts)
	end
	)
	end)

	IO.puts("Generating iterations of activities took #{to_sec(time)} sec.\n")
	:ok
	end

	def generate_power_intervals(opts \\ []) do
	count = Keyword.get(opts, :count, 20)
	power = Keyword.get(opts, :power, 2)
	IO.puts("Generating #{count} intervals for a power #{power} series...")
	counts = Enum.map(1..count, fn n -> :math.pow(n, power) end)
	sum = Enum.sum(counts)

	densities =
	Enum.map(counts, fn c ->
	c / sum
	end)

	densities
	\|> Enum.reduce(0, fn density, acc ->
	if acc == 0 do
	[{0, density}]
	else
	[{_, lower} \| _] = acc
	[{lower, lower + density} \| acc]
	end
	end)
	\|> Enum.reverse()
	end

	def generate_tagged_activities(opts \\ []) do
	tag_count = Keyword.get(opts, :tag_count, 20)
	users = Keyword.get(opts, :users, Repo.all(Pleroma.User))
	activity_count = Keyword.get(opts, :count, 200_000)

	intervals = generate_power_intervals(count: tag_count)

	IO.puts(
	"Generating #{activity_count} activities using #{tag_count} different tags of format `tag_n`, starting at tag_0"
	)

	Enum.each(1..activity_count, fn _ ->
	random = :rand.uniform()
	i = Enum.find_index(intervals, fn {lower, upper} -> lower <= random && upper > random end)
	CommonAPI.post(Enum.random(users), %{status: "a post with the tag #tag_#{i}"})
	end)
	end

	defp generate_long_thread(visibility, users, _opts) do
	group =
	if visibility == "public",
	do: :friends_local,
	else: :user

	tasks = get_reply_tasks(visibility, group) \|> Stream.cycle() \|> Enum.take(50)

	{:ok, activity} =
	CommonAPI.post(users[:user], %{
	status: "Start of #{visibility} long thread",
	visibility: visibility
	})

	Agent.update(:benchmark_state, fn state ->
	key =
	if visibility == "public",
	do: :public_thread,
	else: :private_thread

	Map.put(state, key, activity)
	end)

	acc = {activity.id, ["@" <> users[:user].nickname, "reply to long thread"]}
	insert_replies_for_long_thread(tasks, visibility, users, acc)
	IO.puts("Generating #{visibility} long thread ended\n")
	end

	defp insert_replies_for_long_thread(tasks, visibility, users, acc) do
	Enum.reduce(tasks, acc, fn
	:user, {id, data} ->
	user = users[:user]
	insert_reply(user, List.delete(data, "@" <> user.nickname), id, visibility)

	group, {id, data} ->
	replier = Enum.random(users[group])
	insert_reply(replier, List.delete(data, "@" <> replier.nickname), id, visibility)
	end)
	end

	defp generate_activities(users, task_data, opts) do
	Task.async_stream(
	task_data,
	fn {visibility, type, group} ->
	insert_activity(type, visibility, group, users, opts)
	end,
	max_concurrency: @max_concurrency,
	timeout: 30_000
	)
	\|> Stream.run()
	end

	defp insert_local_activity(visibility, group, users, status) do
	{:ok, _} =
	group
	\|> get_actor(users)
	\|> CommonAPI.post(%{status: status, visibility: visibility})
	end

	defp insert_remote_activity(visibility, group, users, status) do
	actor = get_actor(group, users)
	{act_data, obj_data} = prepare_activity_data(actor, visibility, users[:user])
	{activity_data, object_data} = other_data(actor, status)

	activity_data
	\|> Map.merge(act_data)
	\|> Map.put("object", Map.merge(object_data, obj_data))
	\|> Pleroma.Web.ActivityPub.ActivityPub.insert(false)
	end

	defp user_mentions(users) do
	user_mentions =
	Enum.reduce(
	@groups,
	[],
	fn group, acc ->
	acc ++ get_random_mentions(users[group], Enum.random(0..2))
	end
	)

	if Enum.random([true, false]),
	do: ["@" <> users[:user].nickname \| user_mentions],
	else: user_mentions
	end

	defp hell_thread_mentions(users) do
	with {:ok, nil} <- Cachex.get(:user_cache, "hell_thread_mentions") do
	cached =
	@groups
	\|> Enum.reduce([users[:user]], fn group, acc ->
	acc ++ Enum.take(users[group], 5)
	end)
	\|> Enum.map(&"@#{&1.nickname}")
	\|> Enum.join(", ")

	Cachex.put(:user_cache, "hell_thread_mentions", cached)
	cached
	else
	{:ok, cached} -> cached
	end
	end

	defp insert_activity(:simple, visibility, group, users, _opts)
	when group in @remote_groups do
	insert_remote_activity(visibility, group, users, "Remote status")
	end

	defp insert_activity(:simple, visibility, group, users, _opts) do
	insert_local_activity(visibility, group, users, "Simple status")
	end

	defp insert_activity(:simple_filtered, visibility, group, users, _opts)
	when group in @remote_groups do
	insert_remote_activity(visibility, group, users, "Remote status which must be filtered")
	end

	defp insert_activity(:simple_filtered, visibility, group, users, _opts) do
	insert_local_activity(visibility, group, users, "Simple status which must be filtered")
	end

	defp insert_activity(:emoji, visibility, group, users, _opts)
	when group in @remote_groups do
	insert_remote_activity(visibility, group, users, "Remote status with emoji :firefox:")
	end

	defp insert_activity(:emoji, visibility, group, users, _opts) do
	insert_local_activity(visibility, group, users, "Simple status with emoji :firefox:")
	end

	defp insert_activity(:mentions, visibility, group, users, _opts)
	when group in @remote_groups do
	mentions = user_mentions(users)

	status = Enum.join(mentions, ", ") <> " remote status with mentions"

	insert_remote_activity(visibility, group, users, status)
	end

	defp insert_activity(:mentions, visibility, group, users, _opts) do
	mentions = user_mentions(users)

	status = Enum.join(mentions, ", ") <> " simple status with mentions"
	insert_remote_activity(visibility, group, users, status)
	end

	defp insert_activity(:hell_thread, visibility, group, users, _)
	when group in @remote_groups do
	mentions = hell_thread_mentions(users)
	insert_remote_activity(visibility, group, users, mentions <> " remote hell thread status")
	end

	defp insert_activity(:hell_thread, visibility, group, users, _opts) do
	mentions = hell_thread_mentions(users)

	insert_local_activity(visibility, group, users, mentions <> " hell thread status")
	end

	defp insert_activity(:attachment, visibility, group, users, _opts) do
	actor = get_actor(group, users)

	obj_data = %{
	"actor" => actor.ap_id,
	"name" => "4467-11.jpg",
	"type" => "Document",
	"url" => [
	%{
	"href" =>
	- "#{Pleroma.Web.base_url()}/media/b1b873552422a07bf53af01f3c231c841db4dfc42c35efde681abaf0f2a4eab7.jpg",
	+ "#{Pleroma.Web.Endpoint.url()}/media/b1b873552422a07bf53af01f3c231c841db4dfc42c35efde681abaf0f2a4eab7.jpg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	}

	object = Repo.insert!(%Pleroma.Object{data: obj_data})

	{:ok, _activity} =
	CommonAPI.post(actor, %{
	status: "Post with attachment",
	visibility: visibility,
	media_ids: [object.id]
	})
	end

	defp insert_activity(:tag, visibility, group, users, _opts) do
	insert_local_activity(visibility, group, users, "Status with #tag")
	end

	defp insert_activity(:like, visibility, group, users, opts) do
	actor = get_actor(group, users)

	with activity_id when not is_nil(activity_id) <- get_random_create_activity_id(),
	{:ok, _activity} <- CommonAPI.favorite(actor, activity_id) do
	:ok
	else
	{:error, _} ->
	insert_activity(:like, visibility, group, users, opts)

	nil ->
	Process.sleep(15)
	insert_activity(:like, visibility, group, users, opts)
	end
	end

	defp insert_activity(:reblog, visibility, group, users, opts) do
	actor = get_actor(group, users)

	with activity_id when not is_nil(activity_id) <- get_random_create_activity_id(),
	{:ok, _activity} <- CommonAPI.repeat(activity_id, actor) do
	:ok
	else
	{:error, _} ->
	insert_activity(:reblog, visibility, group, users, opts)

	nil ->
	Process.sleep(15)
	insert_activity(:reblog, visibility, group, users, opts)
	end
	end

	defp insert_activity(:simple_thread, "direct", group, users, _opts) do
	actor = get_actor(group, users)
	tasks = get_reply_tasks("direct", group)

	list =
	case group do
	:user ->
	group = Enum.random(@friends_groups)
	Enum.take(users[group], 3)

	_ ->
	Enum.take(users[group], 3)
	end

	data = Enum.map(list, &("@" <> &1.nickname))

	{:ok, activity} =
	CommonAPI.post(actor, %{
	status: Enum.join(data, ", ") <> "simple status",
	visibility: "direct"
	})

	acc = {activity.id, ["@" <> users[:user].nickname \| data] ++ ["reply to status"]}
	insert_direct_replies(tasks, users[:user], list, acc)
	end

	defp insert_activity(:simple_thread, visibility, group, users, _opts) do
	actor = get_actor(group, users)
	tasks = get_reply_tasks(visibility, group)

	{:ok, activity} =
	CommonAPI.post(users[:user], %{status: "Simple status", visibility: visibility})

	acc = {activity.id, ["@" <> actor.nickname, "reply to status"]}
	insert_replies(tasks, visibility, users, acc)
	end

	defp get_actor(:user, %{user: user}), do: user
	defp get_actor(group, users), do: Enum.random(users[group])

	defp other_data(actor, content) do
	%{host: host} = URI.parse(actor.ap_id)
	datetime = DateTime.utc_now()
	context_id = "https://#{host}/contexts/#{UUID.generate()}"
	activity_id = "https://#{host}/activities/#{UUID.generate()}"
	object_id = "https://#{host}/objects/#{UUID.generate()}"

	activity_data = %{
	"actor" => actor.ap_id,
	"context" => context_id,
	"id" => activity_id,
	"published" => datetime,
	"type" => "Create",
	"directMessage" => false
	}

	object_data = %{
	"actor" => actor.ap_id,
	"attachment" => [],
	"attributedTo" => actor.ap_id,
	"bcc" => [],
	"bto" => [],
	"content" => content,
	"context" => context_id,
	"conversation" => context_id,
	"emoji" => %{},
	"id" => object_id,
	"published" => datetime,
	"sensitive" => false,
	"summary" => "",
	"tag" => [],
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"type" => "Note"
	}

	{activity_data, object_data}
	end

	defp prepare_activity_data(actor, "public", _mention) do
	obj_data = %{
	"cc" => [actor.follower_address],
	"to" => [Constants.as_public()]
	}

	act_data = %{
	"cc" => [actor.follower_address],
	"to" => [Constants.as_public()]
	}

	{act_data, obj_data}
	end

	defp prepare_activity_data(actor, "private", _mention) do
	obj_data = %{
	"cc" => [],
	"to" => [actor.follower_address]
	}

	act_data = %{
	"cc" => [],
	"to" => [actor.follower_address]
	}

	{act_data, obj_data}
	end

	defp prepare_activity_data(actor, "unlisted", _mention) do
	obj_data = %{
	"cc" => [Constants.as_public()],
	"to" => [actor.follower_address]
	}

	act_data = %{
	"cc" => [Constants.as_public()],
	"to" => [actor.follower_address]
	}

	{act_data, obj_data}
	end

	defp prepare_activity_data(_actor, "direct", mention) do
	%{host: mentioned_host} = URI.parse(mention.ap_id)

	obj_data = %{
	"cc" => [],
	"content" =>
	"<span class=\"h-card\"><a class=\"u-url mention\" href=\"#{mention.ap_id}\" rel=\"ugc\">@<span>#{
	mention.nickname
	}</span></a></span> direct message",
	"tag" => [
	%{
	"href" => mention.ap_id,
	"name" => "@#{mention.nickname}@#{mentioned_host}",
	"type" => "Mention"
	}
	],
	"to" => [mention.ap_id]
	}

	act_data = %{
	"cc" => [],
	"directMessage" => true,
	"to" => [mention.ap_id]
	}

	{act_data, obj_data}
	end

	defp get_reply_tasks("public", :user) do
	[:friends_local, :friends_remote, :non_friends_local, :non_friends_remote, :user]
	end

	defp get_reply_tasks("public", group) when group in @friends_groups do
	[:non_friends_local, :non_friends_remote, :user, :friends_local, :friends_remote]
	end

	defp get_reply_tasks("public", group) when group in @non_friends_groups do
	[:user, :friends_local, :friends_remote, :non_friends_local, :non_friends_remote]
	end

	defp get_reply_tasks(visibility, :user) when visibility in ["unlisted", "private"] do
	[:friends_local, :friends_remote, :user, :friends_local, :friends_remote]
	end

	defp get_reply_tasks(visibility, group)
	when visibility in ["unlisted", "private"] and group in @friends_groups do
	[:user, :friends_remote, :friends_local, :user]
	end

	defp get_reply_tasks(visibility, group)
	when visibility in ["unlisted", "private"] and
	group in @non_friends_groups,
	do: []

	defp get_reply_tasks("direct", :user), do: [:friends_local, :user, :friends_remote]

	defp get_reply_tasks("direct", group) when group in @friends_groups,
	do: [:user, group, :user]

	defp get_reply_tasks("direct", group) when group in @non_friends_groups do
	[:user, :non_friends_remote, :user, :non_friends_local]
	end

	defp insert_replies(tasks, visibility, users, acc) do
	Enum.reduce(tasks, acc, fn
	:user, {id, data} ->
	insert_reply(users[:user], data, id, visibility)

	group, {id, data} ->
	replier = Enum.random(users[group])
	insert_reply(replier, data, id, visibility)
	end)
	end

	defp insert_direct_replies(tasks, user, list, acc) do
	Enum.reduce(tasks, acc, fn
	:user, {id, data} ->
	{reply_id, _} = insert_reply(user, List.delete(data, "@" <> user.nickname), id, "direct")
	{reply_id, data}

	_, {id, data} ->
	actor = Enum.random(list)

	{reply_id, _} =
	insert_reply(actor, List.delete(data, "@" <> actor.nickname), id, "direct")

	{reply_id, data}
	end)
	end

	defp insert_reply(actor, data, activity_id, visibility) do
	{:ok, reply} =
	CommonAPI.post(actor, %{
	status: Enum.join(data, ", "),
	visibility: visibility,
	in_reply_to_status_id: activity_id
	})

	{reply.id, ["@" <> actor.nickname \| data]}
	end

	defp get_random_mentions(_users, count) when count == 0, do: []

	defp get_random_mentions(users, count) do
	users
	\|> Enum.shuffle()
	\|> Enum.take(count)
	\|> Enum.map(&"@#{&1.nickname}")
	end

	defp get_random_create_activity_id do
	Repo.one(
	from(a in Pleroma.Activity,
	where: fragment("(?)->>'type' = ?", a.data, ^"Create"),
	order_by: fragment("RANDOM()"),
	limit: 1,
	select: a.id
	)
	)
	end
	end
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index c853a2bb4..e67646a9a 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,312 +1,312 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Application do
	use Application

	import Cachex.Spec

	alias Pleroma.Config

	require Logger

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]
	@mix_env Mix.env()

	def name, do: @name
	def version, do: @version
	def named_version, do: @name <> " " <> @version
	def repository, do: @repository

	def user_agent do
	if Process.whereis(Pleroma.Web.Endpoint) do
	case Config.get([:http, :user_agent], :default) do
	:default ->
	- info = "#{Pleroma.Web.base_url()} <#{Config.get([:instance, :email], "")}>"
	+ info = "#{Pleroma.Web.Endpoint.url()} <#{Config.get([:instance, :email], "")}>"
	named_version() <> "; " <> info

	custom ->
	custom
	end
	else
	# fallback, if endpoint is not started yet
	"Pleroma Data Loader"
	end
	end

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	# Scrubbers are compiled at runtime and therefore will cause a conflict
	# every time the application is restarted, so we disable module
	# conflicts at runtime
	Code.compiler_options(ignore_module_conflict: true)
	# Disable warnings_as_errors at runtime, it breaks Phoenix live reload
	# due to protocol consolidation warnings
	Code.compiler_options(warnings_as_errors: false)
	Pleroma.Telemetry.Logger.attach()
	Config.Holder.save_default()
	Pleroma.HTML.compile_scrubbers()
	Pleroma.Config.Oban.warn()
	Config.DeprecationWarnings.warn()
	Pleroma.Web.Plugs.HTTPSecurityPlug.warn_if_disabled()
	Pleroma.ApplicationRequirements.verify!()
	setup_instrumenters()
	load_custom_modules()
	Pleroma.Docs.JSON.compile()
	limiters_setup()

	adapter = Application.get_env(:tesla, :adapter)

	if adapter == Tesla.Adapter.Gun do
	if version = Pleroma.OTPVersion.version() do
	[major, minor] =
	version
	\|> String.split(".")
	\|> Enum.map(&String.to_integer/1)
	\|> Enum.take(2)

	if (major == 22 and minor < 2) or major < 22 do
	raise "
	!!!OTP VERSION WARNING!!!
	You are using gun adapter with OTP version #{version}, which doesn't support correct handling of unordered certificates chains. Please update your Erlang/OTP to at least 22.2.
	"
	end
	else
	raise "
	!!!OTP VERSION WARNING!!!
	To support correct handling of unordered certificates chains - OTP version must be > 22.2.
	"
	end
	end

	# Define workers and child supervisors to be supervised
	children =
	[
	Pleroma.Repo,
	Config.TransferTask,
	Pleroma.Emoji,
	Pleroma.Web.Plugs.RateLimiter.Supervisor
	] ++
	cachex_children() ++
	http_children(adapter, @mix_env) ++
	[
	Pleroma.Stats,
	Pleroma.JobQueueMonitor,
	{Majic.Pool, [name: Pleroma.MajicPool, pool_size: Config.get([:majic_pool, :size], 2)]},
	{Oban, Config.get(Oban)},
	Pleroma.Web.Endpoint
	] ++
	task_children(@mix_env) ++
	dont_run_in_test(@mix_env) ++
	chat_child(chat_enabled?()) ++
	[
	Pleroma.Gopher.Server
	]

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
	result = Supervisor.start_link(children, opts)

	set_postgres_server_version()

	result
	end

	defp set_postgres_server_version do
	version =
	with %{rows: [[version]]} <- Ecto.Adapters.SQL.query!(Pleroma.Repo, "show server_version"),
	{num, _} <- Float.parse(version) do
	num
	else
	e ->
	Logger.warn(
	"Could not get the postgres version: #{inspect(e)}.\nSetting the default value of 9.6"
	)

	9.6
	end

	:persistent_term.put({Pleroma.Repo, :postgres_version}, version)
	end

	def load_custom_modules do
	dir = Config.get([:modules, :runtime_dir])

	if dir && File.exists?(dir) do
	dir
	\|> Pleroma.Utils.compile_dir()
	\|> case do
	{:error, _errors, _warnings} ->
	raise "Invalid custom modules"

	{:ok, modules, _warnings} ->
	if @mix_env != :test do
	Enum.each(modules, fn mod ->
	Logger.info("Custom module loaded: #{inspect(mod)}")
	end)
	end

	:ok
	end
	end
	end

	defp setup_instrumenters do
	require Prometheus.Registry

	if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
	:ok =
	:telemetry.attach(
	"prometheus-ecto",
	[:pleroma, :repo, :query],
	&Pleroma.Repo.Instrumenter.handle_event/4,
	%{}
	)

	Pleroma.Repo.Instrumenter.setup()
	end

	Pleroma.Web.Endpoint.MetricsExporter.setup()
	Pleroma.Web.Endpoint.PipelineInstrumenter.setup()

	# Note: disabled until prometheus-phx is integrated into prometheus-phoenix:
	# Pleroma.Web.Endpoint.Instrumenter.setup()
	PrometheusPhx.setup()
	end

	defp cachex_children do
	[
	build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
	build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
	build_cachex("scrubber", limit: 2500),
	build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500),
	build_cachex("web_resp", limit: 2500),
	build_cachex("emoji_packs", expiration: emoji_packs_expiration(), limit: 10),
	build_cachex("failed_proxy_url", limit: 2500),
	build_cachex("banned_urls", default_ttl: :timer.hours(24 * 30), limit: 5_000),
	build_cachex("chat_message_id_idempotency_key",
	expiration: chat_message_id_idempotency_key_expiration(),
	limit: 500_000
	)
	]
	end

	defp emoji_packs_expiration,
	do: expiration(default: :timer.seconds(5 * 60), interval: :timer.seconds(60))

	defp idempotency_expiration,
	do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))

	defp chat_message_id_idempotency_key_expiration,
	do: expiration(default: :timer.minutes(2), interval: :timer.seconds(60))

	defp seconds_valid_interval,
	do: :timer.seconds(Config.get!([Pleroma.Captcha, :seconds_valid]))

	@spec build_cachex(String.t(), keyword()) :: map()
	def build_cachex(type, opts),
	do: %{
	id: String.to_atom("cachex_" <> type),
	start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
	type: :worker
	}

	defp chat_enabled?, do: Config.get([:chat, :enabled])

	defp dont_run_in_test(env) when env in [:test, :benchmark], do: []

	defp dont_run_in_test(_) do
	[
	{Registry,
	[
	name: Pleroma.Web.Streamer.registry(),
	keys: :duplicate,
	partitions: System.schedulers_online()
	]}
	]
	end

	defp chat_child(true) do
	[
	Pleroma.Web.ChatChannel.ChatChannelState,
	{Phoenix.PubSub, [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2]}
	]
	end

	defp chat_child(_), do: []

	defp task_children(:test) do
	[
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	}
	]
	end

	defp task_children(_) do
	[
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	},
	%{
	id: :internal_fetch_init,
	start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
	restart: :temporary
	}
	]
	end

	# start hackney and gun pools in tests
	defp http_children(_, :test) do
	http_children(Tesla.Adapter.Hackney, nil) ++ http_children(Tesla.Adapter.Gun, nil)
	end

	defp http_children(Tesla.Adapter.Hackney, _) do
	pools = [:federation, :media]

	pools =
	if Config.get([Pleroma.Upload, :proxy_remote]) do
	[:upload \| pools]
	else
	pools
	end

	for pool <- pools do
	options = Config.get([:hackney_pools, pool])
	:hackney_pool.child_spec(pool, options)
	end
	end

	defp http_children(Tesla.Adapter.Gun, _) do
	Pleroma.Gun.ConnectionPool.children() ++
	[{Task, &Pleroma.HTTP.AdapterHelper.Gun.limiter_setup/0}]
	end

	defp http_children(_, _), do: []

	@spec limiters_setup() :: :ok
	def limiters_setup do
	config = Config.get(ConcurrentLimiter, [])

	[Pleroma.Web.RichMedia.Helpers, Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy]
	\|> Enum.each(fn module ->
	mod_config = Keyword.get(config, module, [])

	max_running = Keyword.get(mod_config, :max_running, 5)
	max_waiting = Keyword.get(mod_config, :max_waiting, 5)

	ConcurrentLimiter.new(module, max_running, max_waiting)
	end)
	end
	end
	diff --git a/lib/pleroma/constants.ex b/lib/pleroma/constants.ex
	index b24338cc6..bdca8279c 100644
	--- a/lib/pleroma/constants.ex
	+++ b/lib/pleroma/constants.ex
	@@ -1,32 +1,32 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Constants do
	use Const

	const(as_public, do: "https://www.w3.org/ns/activitystreams#Public")

	const(object_internal_fields,
	do: [
	"reactions",
	"reaction_count",
	"likes",
	"like_count",
	"announcements",
	"announcement_count",
	"emoji",
	"context_id",
	"deleted_activity_id",
	"pleroma_internal",
	"generator"
	]
	)

	const(static_only_files,
	do:
	~w(index.html robots.txt static static-fe finmoji emoji packs sounds images instance sw.js sw-pleroma.js favicon.png schemas doc embed.js embed.css)
	)

	- def as_local_public, do: Pleroma.Web.base_url() <> "/#Public"
	+ def as_local_public, do: Pleroma.Web.Endpoint.url() <> "/#Public"
	end
	diff --git a/lib/pleroma/emails/admin_email.ex b/lib/pleroma/emails/admin_email.ex
	index 5fe74e2f7..88bc78aec 100644
	--- a/lib/pleroma/emails/admin_email.ex
	+++ b/lib/pleroma/emails/admin_email.ex
	@@ -1,99 +1,99 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emails.AdminEmail do
	@moduledoc "Admin emails"

	import Swoosh.Email

	alias Pleroma.Config
	alias Pleroma.HTML
	alias Pleroma.Web.Router.Helpers

	defp instance_config, do: Config.get(:instance)
	defp instance_name, do: instance_config()[:name]

	defp instance_notify_email do
	Keyword.get(instance_config(), :notify_email, instance_config()[:email])
	end

	def test_email(mail_to \\ nil) do
	html_body = """
	<h3>Instance Test Email</h3>
	<p>A test email was requested. Hello. :)</p>
	"""

	new()
	\|> to(mail_to \|\| Config.get([:instance, :email]))
	\|> from({instance_name(), instance_notify_email()})
	\|> subject("Instance Test Email")
	\|> html_body(html_body)
	end

	def report(to, reporter, account, statuses, comment) do
	comment_html =
	if comment do
	"<p>Comment: #{comment}"
	else
	""
	end

	statuses_html =
	if is_list(statuses) && length(statuses) > 0 do
	statuses_list_html =
	statuses
	\|> Enum.map(fn
	%{id: id} ->
	status_url = Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, id)
	"<li><a href=\"#{status_url}\">#{status_url}</li>"

	%{"id" => id} when is_binary(id) ->
	"<li><a href=\"#{id}\">#{id}</li>"

	id when is_binary(id) ->
	"<li><a href=\"#{id}\">#{id}</li>"
	end)
	\|> Enum.join("\n")

	"""
	<p> Statuses:
	<ul>
	#{statuses_list_html}
	</ul>
	</p>
	"""
	else
	""
	end

	html_body = """
	<p>Reported by: <a href="#{reporter.ap_id}">#{reporter.nickname}</a></p>
	<p>Reported Account: <a href="#{account.ap_id}">#{account.nickname}</a></p>
	#{comment_html}
	#{statuses_html}
	<p>
	- <a href="#{Pleroma.Web.base_url()}/pleroma/admin/#/reports/index">View Reports in AdminFE</a>
	+ <a href="#{Pleroma.Web.Endpoint.url()}/pleroma/admin/#/reports/index">View Reports in AdminFE</a>
	"""

	new()
	\|> to({to.name, to.email})
	\|> from({instance_name(), instance_notify_email()})
	\|> subject("#{instance_name()} Report")
	\|> html_body(html_body)
	end

	def new_unapproved_registration(to, account) do
	html_body = """
	<p>New account for review: <a href="#{account.ap_id}">@#{account.nickname}</a></p>
	<blockquote>#{HTML.strip_tags(account.registration_reason)}</blockquote>
	- <a href="#{Pleroma.Web.base_url()}/pleroma/admin/#/users/#{account.id}/">Visit AdminFE</a>
	+ <a href="#{Pleroma.Web.Endpoint.url()}/pleroma/admin/#/users/#{account.id}/">Visit AdminFE</a>
	"""

	new()
	\|> to({to.name, to.email})
	\|> from({instance_name(), instance_notify_email()})
	\|> subject("New account up for review on #{instance_name()} (@#{account.nickname})")
	\|> html_body(html_body)
	end
	end
	diff --git a/lib/pleroma/emoji/formatter.ex b/lib/pleroma/emoji/formatter.ex
	index 50150e951..ddbbc9d5d 100644
	--- a/lib/pleroma/emoji/formatter.ex
	+++ b/lib/pleroma/emoji/formatter.ex
	@@ -1,52 +1,52 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	def emojify(text, nil), do: text

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

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

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

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

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

	def demojify(text, nil), do: text

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

	def get_emoji_map(_), do: %{}
	end
	diff --git a/lib/pleroma/formatter.ex b/lib/pleroma/formatter.ex
	index 7a08e48a9..535ad5f10 100644
	--- a/lib/pleroma/formatter.ex
	+++ b/lib/pleroma/formatter.ex
	@@ -1,155 +1,155 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Formatter do
	alias Pleroma.HTML
	alias Pleroma.User

	@safe_mention_regex ~r/^(\s(?<mentions>(@.+?\s+){1,})+)(?<rest>.)/s
	@link_regex ~r"((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~%:/?#[\]@!\$&'\\+,;=.]+)\|[0-9a-z+\-\.]+:[0-9a-z$-_.+!'(),]+"ui
	@markdown_characters_regex ~r/(`\|\*\|_\|{\|}\|[\|]\|$\|$\|#\|\+\|-\|\.\|!)/

	defp linkify_opts do
	Pleroma.Config.get(Pleroma.Formatter) ++
	[
	hashtag: true,
	hashtag_handler: &Pleroma.Formatter.hashtag_handler/4,
	mention: true,
	mention_handler: &Pleroma.Formatter.mention_handler/4
	]
	end

	def escape_mention_handler("@" <> nickname = mention, buffer, _, _) do
	case User.get_cached_by_nickname(nickname) do
	%User{} ->
	# escape markdown characters with `\\`
	# (we don't want something like @user__name to be parsed by markdown)
	String.replace(mention, @markdown_characters_regex, "\\\\\\1")

	_ ->
	buffer
	end
	end

	def mention_handler("@" <> nickname, buffer, opts, acc) do
	case User.get_cached_by_nickname(nickname) do
	%User{id: id} = user ->
	user_url = user.uri \|\| user.ap_id
	nickname_text = get_nickname_text(nickname, opts)

	link =
	Phoenix.HTML.Tag.content_tag(
	:span,
	Phoenix.HTML.Tag.content_tag(
	:a,
	["@", Phoenix.HTML.Tag.content_tag(:span, nickname_text)],
	"data-user": id,
	class: "u-url mention",
	href: user_url,
	rel: "ugc"
	),
	class: "h-card"
	)
	\|> Phoenix.HTML.safe_to_string()

	{link, %{acc \| mentions: MapSet.put(acc.mentions, {"@" <> nickname, user})}}

	_ ->
	{buffer, acc}
	end
	end

	def hashtag_handler("#" <> tag = tag_text, _buffer, _opts, acc) do
	tag = String.downcase(tag)
	- url = "#{Pleroma.Web.base_url()}/tag/#{tag}"
	+ url = "#{Pleroma.Web.Endpoint.url()}/tag/#{tag}"

	link =
	Phoenix.HTML.Tag.content_tag(:a, tag_text,
	class: "hashtag",
	"data-tag": tag,
	href: url,
	rel: "tag ugc"
	)
	\|> Phoenix.HTML.safe_to_string()

	{link, %{acc \| tags: MapSet.put(acc.tags, {tag_text, tag})}}
	end

	@doc """
	Parses a text and replace plain text links with HTML. Returns a tuple with a result text, mentions, and hashtags.

	If the 'safe_mention' option is given, only consecutive mentions at the start the post are actually mentioned.
	"""
	@spec linkify(String.t(), keyword()) ::
	{String.t(), [{String.t(), User.t()}], [{String.t(), String.t()}]}
	def linkify(text, options \\ []) do
	options = linkify_opts() ++ options

	if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
	%{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
	acc = %{mentions: MapSet.new(), tags: MapSet.new()}

	{text_mentions, %{mentions: mentions}} = Linkify.link_map(mentions, acc, options)
	{text_rest, %{tags: tags}} = Linkify.link_map(rest, acc, options)

	{text_mentions <> text_rest, MapSet.to_list(mentions), MapSet.to_list(tags)}
	else
	acc = %{mentions: MapSet.new(), tags: MapSet.new()}
	{text, %{mentions: mentions, tags: tags}} = Linkify.link_map(text, acc, options)

	{text, MapSet.to_list(mentions), MapSet.to_list(tags)}
	end
	end

	@doc """
	Escapes a special characters in mention names.
	"""
	def mentions_escape(text, options \\ []) do
	options =
	Keyword.merge(options,
	mention: true,
	url: false,
	mention_handler: &Pleroma.Formatter.escape_mention_handler/4
	)

	if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
	%{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
	Linkify.link(mentions, options) <> Linkify.link(rest, options)
	else
	Linkify.link(text, options)
	end
	end

	def html_escape({text, mentions, hashtags}, type) do
	{html_escape(text, type), mentions, hashtags}
	end

	def html_escape(text, "text/html") do
	HTML.filter_tags(text)
	end

	def html_escape(text, "text/plain") do
	Regex.split(@link_regex, text, include_captures: true)
	\|> Enum.map_every(2, fn chunk ->
	{:safe, part} = Phoenix.HTML.html_escape(chunk)
	part
	end)
	\|> Enum.join("")
	end

	def truncate(text, max_length \\ 200, omission \\ "...") do
	# Remove trailing whitespace
	text = Regex.replace(~r/([^ \t\r\n])([ \t]+$)/u, text, "\\g{1}")

	if String.length(text) < max_length do
	text
	else
	length_with_omission = max_length - String.length(omission)
	String.slice(text, 0, length_with_omission) <> omission
	end
	end

	defp get_nickname_text(nickname, %{mentions_format: :full}), do: User.full_nickname(nickname)
	defp get_nickname_text(nickname, _), do: User.local_nickname(nickname)
	end
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index aaf123840..f0e15f0f7 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,352 +1,352 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 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.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)

	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(
	"COALESCE(?->'object'->>'id', ?->>'object') = (? ->> 'id') AND (?->>'type' = ?) ",
	a.data,
	a.data,
	object.data,
	a.data,
	^activity_type
	),
	as: :object_activity
	)
	end

	def create(data) do
	Object.change(%Object{}, %{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)
	end

	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])

	# 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
	if Keyword.get(options, :fetch) do
	Fetcher.fetch_object_from_id!(ap_id, options)
	else
	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 context_mapping(context) do
	Object.change(%Object{}, %{data: %{"id" => context}})
	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)

	object
	\|> Object.change(%{data: tombstone})
	\|> Repo.update()
	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}
	)

	{:ok, object, deleted_activity}
	end
	end

	@spec cleanup_attachments(boolean(), %{required(:object) => map()}) ::
	{:ok, Oban.Job.t() \| nil}
	def cleanup_attachments(true, %{"object" => _} = params) do
	AttachmentsCleanupWorker.enqueue("cleanup_attachments", params)
	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_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.base_url() <> "/")
	+ 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))
	end
	diff --git a/lib/pleroma/upload.ex b/lib/pleroma/upload.ex
	index 654711351..b32131bb6 100644
	--- a/lib/pleroma/upload.ex
	+++ b/lib/pleroma/upload.ex
	@@ -1,257 +1,257 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 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.

	Related behaviors:

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

	"""
	alias Ecto.UUID
	alias Pleroma.Config
	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()]}

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

	defp get_description(opts, upload) do
	case {opts[: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.t()} \| {: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(opts, 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,
	%{
	"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)
	}
	],
	"name" => description
	}}
	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
	}}
	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), lower: true)

	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
	}}
	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.get([Pleroma.Upload, :uploader])
	upload_base_url = Config.get([Pleroma.Upload, :base_url])
	public_endpoint = Config.get([uploader, :public_endpoint])

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

	Pleroma.Uploaders.S3 ->
	bucket = Config.get([Pleroma.Uploaders.S3, :bucket])
	truncated_namespace = Config.get([Pleroma.Uploaders.S3, :truncated_namespace])
	namespace = Config.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.base_url() <> "/media/"
	+ 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 9942617d8..5057bb3c3 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2493 +1,2493 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 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
	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.OAuth
	alias Pleroma.Web.RelMe
	alias Pleroma.Workers.BackgroundWorker

	require Logger

	@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
	]
	]

	@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(: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(:ap_enabled, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	field(:mastofe_settings, :map, default: nil)
	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(:pinned_activities, {:array, :string}, default: [])
	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)

	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
	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
	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
	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
	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 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 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 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 superuser?(for_user) 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 superuser?(User.t()) :: boolean()
	def superuser?(%User{local: true, is_admin: true}), do: true
	def superuser?(%User{local: true, is_moderator: true}), do: true
	def superuser?(_), do: false

	@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], "#{Web.base_url()}/images/avi.png")
	+ Config.get([:assets, :default_user_avatar], "#{Web.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] && "#{Web.base_url()}/images/banner.png"
	+ _ -> !options[:no_default] && "#{Web.Endpoint.url()}/images/banner.png"
	end
	end

	# Should probably be renamed or removed
	- def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"
	+ def ap_id(%User{nickname: nickname}), do: "#{Web.Endpoint.url()}/users/#{nickname}"

	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"

	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,
	:ap_enabled,
	:banner,
	:is_locked,
	:last_refreshed_at,
	:uri,
	:follower_address,
	:following_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
	]
	)
	\|> 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
	]
	)
	\|> 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, ["Person", "Service"])
	\|> 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
	_ -> 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, 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, 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_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_address()
	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
	])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_change(:email, fn :email, email ->
	valid? =
	Config.get([User, :email_blacklist])
	\|> Enum.all?(fn blacklisted_domain ->
	!String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
	end)

	if valid?, do: [], else: [email: "Invalid email"]
	end)
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
	\|> 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])
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_address()
	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 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_address(changeset) do
	followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})

	changeset
	\|> put_change(:follower_address, followers)
	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) do
	user
	\|> Pleroma.Emails.UserEmail.approval_pending_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	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(Uset.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()} \| {: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
	if not ap_enabled?(followed) do
	follow(follower, followed)
	else
	{:ok, follower, followed}
	end
	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_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)
	expires_in = Map.get(params, :expires_in, 0)

	with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee),
	{:ok, user_notification_mute} <-
	(notifications? && UserRelationship.create_notification_mute(muter, mutee)) \|\|
	{:ok, nil} do
	if expires_in > 0 do
	Pleroma.Workers.MuteExpireWorker.enqueue(
	"unmute_user",
	%{"muter_id" => muter.id, "mutee_id" => mutee.id},
	schedule_in: expires_in
	)
	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.warn(
	"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 as well
	blocked =
	case CommonAPI.reject_follow_request(blocked, blocker) do
	{:ok, %User{} = updated_blocked} -> updated_blocked
	nil -> blocked
	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 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

	@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, Changeset.t()}
	def set_activation(users, status) when is_list(users) do
	Repo.transaction(fn ->
	for user <- users, do: set_activation(user, status)
	end)
	end

	@spec set_activation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, 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 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()) :: 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,
	keys: nil,
	public_key: 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,
	is_confirmed: true,
	password_reset_pending: false,
	is_approved: true,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	is_active: false,
	ap_enabled: false,
	is_moderator: false,
	is_admin: false,
	mastofe_settings: nil,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	})
	end

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

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

	defp delete_and_invalidate_cache(%User{} = user) do
	invalidate_cache(user)
	Repo.delete(user)
	end

	defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)

	defp delete_or_deactivate(%User{local: true} = user) do
	status = account_status(user)

	case status do
	:confirmation_pending ->
	delete_and_invalidate_cache(user)

	:approval_pending ->
	delete_and_invalidate_cache(user)

	_ ->
	user
	\|> purge_user_changeset()
	\|> update_and_set_cache()
	end
	end

	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
	# 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)

	delete_or_deactivate(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
	\|> 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 {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
	{:ok, public_key} <- public_key(user) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

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

	@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(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: host} = URI.parse(user.ap_id)
	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

	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, 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 ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}

	def ensure_keys_present(%User{} = user) do
	with {:ok, pem} <- Keys.generate_rsa_pem() do
	user
	\|> cast(%{keys: pem}, [:keys])
	\|> validate_required([:keys])
	\|> update_and_set_cache()
	end
	end

	def get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	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])
	\|> validate_required([:email])
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> update_and_set_cache()
	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 roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
	%{
	admin: is_admin,
	moderator: is_moderator
	}
	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

	def mastodon_settings_update(user, settings) do
	user
	\|> cast(%{mastofe_settings: settings}, [:mastofe_settings])
	\|> validate_required([:mastofe_settings])
	\|> update_and_set_cache()
	end

	@spec confirmation_changeset(User.t(), keyword()) :: 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()) :: Changeset.t()
	def approval_changeset(user, set_approval: approved?) do
	cast(user, %{is_approved: approved?}, [:is_approved])
	end

	def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
	if id not in user.pinned_activities do
	max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
	params = %{pinned_activities: user.pinned_activities ++ [id]}

	# if pinned activity was scheduled for deletion, we remove job
	if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
	Oban.cancel_job(expiration.id)
	end

	user
	\|> cast(params, [:pinned_activities])
	\|> validate_length(:pinned_activities,
	max: max_pinned_statuses,
	message: "You have already pinned the maximum number of statuses"
	)
	else
	change(user)
	end
	\|> update_and_set_cache()
	end

	def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
	params = %{pinned_activities: List.delete(user.pinned_activities, id)}

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

	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: id,
	expires_at: expires_at
	})
	end

	user
	\|> cast(params, [:pinned_activities])
	\|> 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 active_user_count(weeks \\ 4) do
	active_after = Timex.shift(NaiveDateTime.utc_now(), weeks: -weeks)

	__MODULE__
	\|> where([u], u.last_active_at >= ^active_after)
	\|> where([u], u.local == true)
	\|> Repo.aggregate(:count)
	end
	end
	diff --git a/lib/pleroma/web.ex b/lib/pleroma/web.ex
	index 397e4d1e7..d26931af9 100644
	--- a/lib/pleroma/web.ex
	+++ b/lib/pleroma/web.ex
	@@ -1,238 +1,234 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web do
	@moduledoc """
	A module that keeps using definitions for controllers,
	views and so on.

	This can be used in your application as:

	use Pleroma.Web, :controller
	use Pleroma.Web, :view

	The definitions below will be executed for every view,
	controller, etc, so keep them short and clean, focused
	on imports, uses and aliases.

	Do NOT define functions inside the quoted expressions
	below.
	"""

	alias Pleroma.Helpers.AuthHelper
	alias Pleroma.Web.Plugs.EnsureAuthenticatedPlug
	alias Pleroma.Web.Plugs.EnsurePublicOrAuthenticatedPlug
	alias Pleroma.Web.Plugs.ExpectAuthenticatedCheckPlug
	alias Pleroma.Web.Plugs.ExpectPublicOrAuthenticatedCheckPlug
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.PlugHelper

	def controller do
	quote do
	use Phoenix.Controller, namespace: Pleroma.Web

	import Plug.Conn

	import Pleroma.Web.Gettext
	import Pleroma.Web.TranslationHelpers

	alias Pleroma.Web.Router.Helpers, as: Routes

	plug(:set_put_layout)

	defp set_put_layout(conn, _) do
	put_layout(conn, Pleroma.Config.get(:app_layout, "app.html"))
	end

	# Marks plugs intentionally skipped and blocks their execution if present in plugs chain
	defp skip_plug(conn, plug_modules) do
	plug_modules
	\|> List.wrap()
	\|> Enum.reduce(
	conn,
	fn plug_module, conn ->
	try do
	plug_module.skip_plug(conn)
	rescue
	UndefinedFunctionError ->
	raise "`#{plug_module}` is not skippable. Append `use Pleroma.Web, :plug` to its code."
	end
	end
	)
	end

	# Executed just before actual controller action, invokes before-action hooks (callbacks)
	defp action(conn, params) do
	with %{halted: false} = conn <-
	maybe_drop_authentication_if_oauth_check_ignored(conn),
	%{halted: false} = conn <- maybe_perform_public_or_authenticated_check(conn),
	%{halted: false} = conn <- maybe_perform_authenticated_check(conn),
	%{halted: false} = conn <- maybe_halt_on_missing_oauth_scopes_check(conn) do
	super(conn, params)
	end
	end

	# For non-authenticated API actions, drops auth info if OAuth scopes check was ignored
	# (neither performed nor explicitly skipped)
	defp maybe_drop_authentication_if_oauth_check_ignored(conn) do
	if PlugHelper.plug_called?(conn, ExpectPublicOrAuthenticatedCheckPlug) and
	not PlugHelper.plug_called_or_skipped?(conn, OAuthScopesPlug) do
	AuthHelper.drop_auth_info(conn)
	else
	conn
	end
	end

	# Ensures instance is public -or- user is authenticated if such check was scheduled
	defp maybe_perform_public_or_authenticated_check(conn) do
	if PlugHelper.plug_called?(conn, ExpectPublicOrAuthenticatedCheckPlug) do
	EnsurePublicOrAuthenticatedPlug.call(conn, %{})
	else
	conn
	end
	end

	# Ensures user is authenticated if such check was scheduled
	# Note: runs prior to action even if it was already executed earlier in plug chain
	# (since OAuthScopesPlug has option of proceeding unauthenticated)
	defp maybe_perform_authenticated_check(conn) do
	if PlugHelper.plug_called?(conn, ExpectAuthenticatedCheckPlug) do
	EnsureAuthenticatedPlug.call(conn, %{})
	else
	conn
	end
	end

	# Halts if authenticated API action neither performs nor explicitly skips OAuth scopes check
	defp maybe_halt_on_missing_oauth_scopes_check(conn) do
	if PlugHelper.plug_called?(conn, ExpectAuthenticatedCheckPlug) and
	not PlugHelper.plug_called_or_skipped?(conn, OAuthScopesPlug) do
	conn
	\|> render_error(
	:forbidden,
	"Security violation: OAuth scopes check was neither handled nor explicitly skipped."
	)
	\|> halt()
	else
	conn
	end
	end
	end
	end

	def view do
	quote do
	use Phoenix.View,
	root: "lib/pleroma/web/templates",
	namespace: Pleroma.Web

	# Import convenience functions from controllers
	import Phoenix.Controller, only: [get_csrf_token: 0, get_flash: 2, view_module: 1]

	import Pleroma.Web.ErrorHelpers
	import Pleroma.Web.Gettext

	alias Pleroma.Web.Router.Helpers, as: Routes

	require Logger

	@doc "Same as `render/3` but wrapped in a rescue block"
	def safe_render(view, template, assigns \\ %{}) do
	Phoenix.View.render(view, template, assigns)
	rescue
	error ->
	Logger.error(
	"#{__MODULE__} failed to render #{inspect({view, template})}\n" <>
	Exception.format(:error, error, __STACKTRACE__)
	)

	nil
	end

	@doc """
	Same as `render_many/4` but wrapped in rescue block.
	"""
	def safe_render_many(collection, view, template, assigns \\ %{}) do
	Enum.map(collection, fn resource ->
	as = Map.get(assigns, :as) \|\| view.__resource__
	assigns = Map.put(assigns, as, resource)
	safe_render(view, template, assigns)
	end)
	\|> Enum.filter(& &1)
	end
	end
	end

	def router do
	quote do
	use Phoenix.Router
	# credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
	import Plug.Conn
	import Phoenix.Controller
	end
	end

	def channel do
	quote do
	# credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
	import Phoenix.Channel
	import Pleroma.Web.Gettext
	end
	end

	def plug do
	quote do
	@behaviour Pleroma.Web.Plug
	@behaviour Plug

	@doc """
	Marks a plug intentionally skipped and blocks its execution if it's present in plugs chain.
	"""
	def skip_plug(conn) do
	PlugHelper.append_to_private_list(
	conn,
	PlugHelper.skipped_plugs_list_id(),
	__MODULE__
	)
	end

	@impl Plug
	@doc """
	Before-plug hook that
	* ensures the plug is not skipped
	* processes `:if_func` / `:unless_func` functional pre-run conditions
	* adds plug to the list of called plugs and calls `perform/2` if checks are passed

	Note: multiple invocations of the same plug (with different or same options) are allowed.
	"""
	def call(%Plug.Conn{} = conn, options) do
	if PlugHelper.plug_skipped?(conn, __MODULE__) \|\|
	(options[:if_func] && !options[:if_func].(conn)) \|\|
	(options[:unless_func] && options[:unless_func].(conn)) do
	conn
	else
	conn =
	PlugHelper.append_to_private_list(
	conn,
	PlugHelper.called_plugs_list_id(),
	__MODULE__
	)

	apply(__MODULE__, :perform, [conn, options])
	end
	end
	end
	end

	@doc """
	When used, dispatch to the appropriate controller/view/etc.
	"""
	defmacro __using__(which) when is_atom(which) do
	apply(__MODULE__, which, [])
	end
	-
	- def base_url do
	- Pleroma.Web.Endpoint.url()
	- end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/no_empty_policy.ex b/lib/pleroma/web/activity_pub/mrf/no_empty_policy.ex
	index 32bb1b645..cc1c89043 100644
	--- a/lib/pleroma/web/activity_pub/mrf/no_empty_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/no_empty_policy.ex
	@@ -1,61 +1,61 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.NoEmptyPolicy do
	@moduledoc "Filter local activities which have no content"
	@behaviour Pleroma.Web.ActivityPub.MRF

	alias Pleroma.Web

	@impl true
	def filter(%{"actor" => actor} = object) do
	with true <- is_local?(actor),
	true <- is_note?(object),
	false <- has_attachment?(object),
	true <- only_mentions?(object) do
	{:reject, "[NoEmptyPolicy]"}
	else
	_ ->
	{:ok, object}
	end
	end

	def filter(object), do: {:ok, object}

	defp is_local?(actor) do
	- if actor \|> String.starts_with?("#{Web.base_url()}") do
	+ if actor \|> String.starts_with?("#{Web.Endpoint.url()}") do
	true
	else
	false
	end
	end

	defp has_attachment?(%{
	"type" => "Create",
	"object" => %{"type" => "Note", "attachment" => attachments}
	})
	when length(attachments) > 0,
	do: true

	defp has_attachment?(_), do: false

	defp only_mentions?(%{"type" => "Create", "object" => %{"type" => "Note", "source" => source}}) do
	non_mentions =
	source \|> String.split() \|> Enum.filter(&(not String.starts_with?(&1, "@"))) \|> length

	if non_mentions > 0 do
	false
	else
	true
	end
	end

	defp only_mentions?(_), do: false

	defp is_note?(%{"type" => "Create", "object" => %{"type" => "Note"}}), do: true
	defp is_note?(_), do: false

	@impl true
	def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/publisher.ex b/lib/pleroma/web/activity_pub/publisher.ex
	index b12b2fc24..590beef64 100644
	--- a/lib/pleroma/web/activity_pub/publisher.ex
	+++ b/lib/pleroma/web/activity_pub/publisher.ex
	@@ -1,281 +1,281 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Publisher do
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Delivery
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier

	require Pleroma.Constants

	import Pleroma.Web.ActivityPub.Visibility

	@behaviour Pleroma.Web.Federator.Publisher

	require Logger

	@moduledoc """
	ActivityPub outgoing federation module.
	"""

	@doc """
	Determine if an activity can be represented by running it through Transmogrifier.
	"""
	def is_representable?(%Activity{} = activity) do
	with {:ok, _data} <- Transmogrifier.prepare_outgoing(activity.data) do
	true
	else
	_e ->
	false
	end
	end

	@doc """
	Publish a single message to a peer. Takes a struct with the following
	parameters set:

	* `inbox`: the inbox to publish to
	* `json`: the JSON message body representing the ActivityPub message
	* `actor`: the actor which is signing the message
	* `id`: the ActivityStreams URI of the message
	"""
	def publish_one(%{inbox: inbox, json: json, actor: %User{} = actor, id: id} = params) do
	Logger.debug("Federating #{id} to #{inbox}")
	uri = %{path: path} = URI.parse(inbox)
	digest = "SHA-256=" <> (:crypto.hash(:sha256, json) \|> Base.encode64())

	date = Pleroma.Signature.signed_date()

	signature =
	Pleroma.Signature.sign(actor, %{
	"(request-target)": "post #{path}",
	host: signature_host(uri),
	"content-length": byte_size(json),
	digest: digest,
	date: date
	})

	with {:ok, %{status: code}} when code in 200..299 <-
	result =
	HTTP.post(
	inbox,
	json,
	[
	{"Content-Type", "application/activity+json"},
	{"Date", date},
	{"signature", signature},
	{"digest", digest}
	]
	) do
	if not Map.has_key?(params, :unreachable_since) \|\| params[:unreachable_since] do
	Instances.set_reachable(inbox)
	end

	result
	else
	{_post_result, response} ->
	unless params[:unreachable_since], do: Instances.set_unreachable(inbox)
	{:error, response}
	end
	end

	def publish_one(%{actor_id: actor_id} = params) do
	actor = User.get_cached_by_id(actor_id)

	params
	\|> Map.delete(:actor_id)
	\|> Map.put(:actor, actor)
	\|> publish_one()
	end

	defp signature_host(%URI{port: port, scheme: scheme, host: host}) do
	if port == URI.default_port(scheme) do
	host
	else
	"#{host}:#{port}"
	end
	end

	defp should_federate?(inbox, public) do
	if public do
	true
	else
	%{host: host} = URI.parse(inbox)

	quarantined_instances =
	Config.get([:instance, :quarantined_instances], [])
	\|> Pleroma.Web.ActivityPub.MRF.subdomains_regex()

	!Pleroma.Web.ActivityPub.MRF.subdomain_match?(quarantined_instances, host)
	end
	end

	@spec recipients(User.t(), Activity.t()) :: list(User.t()) \| []
	defp recipients(actor, activity) do
	followers =
	if actor.follower_address in activity.recipients do
	User.get_external_followers(actor)
	else
	[]
	end

	fetchers =
	with %Activity{data: %{"type" => "Delete"}} <- activity,
	%Object{id: object_id} <- Object.normalize(activity, fetch: false),
	fetchers <- User.get_delivered_users_by_object_id(object_id),
	_ <- Delivery.delete_all_by_object_id(object_id) do
	fetchers
	else
	_ ->
	[]
	end

	Pleroma.Web.Federator.Publisher.remote_users(actor, activity) ++ followers ++ fetchers
	end

	defp get_cc_ap_ids(ap_id, recipients) do
	host = Map.get(URI.parse(ap_id), :host)

	recipients
	\|> Enum.filter(fn %User{ap_id: ap_id} -> Map.get(URI.parse(ap_id), :host) == host end)
	\|> Enum.map(& &1.ap_id)
	end

	defp maybe_use_sharedinbox(%User{shared_inbox: nil, inbox: inbox}), do: inbox
	defp maybe_use_sharedinbox(%User{shared_inbox: shared_inbox}), do: shared_inbox

	@doc """
	Determine a user inbox to use based on heuristics. These heuristics
	are based on an approximation of the ``sharedInbox`` rules in the
	[ActivityPub specification][ap-sharedinbox].

	Please do not edit this function (or its children) without reading
	the spec, as editing the code is likely to introduce some breakage
	without some familiarity.

	[ap-sharedinbox]: https://www.w3.org/TR/activitypub/#shared-inbox-delivery
	"""
	def determine_inbox(
	%Activity{data: activity_data},
	%User{inbox: inbox} = user
	) do
	to = activity_data["to"] \|\| []
	cc = activity_data["cc"] \|\| []
	type = activity_data["type"]

	cond do
	type == "Delete" ->
	maybe_use_sharedinbox(user)

	Pleroma.Constants.as_public() in to \|\| Pleroma.Constants.as_public() in cc ->
	maybe_use_sharedinbox(user)

	length(to) + length(cc) > 1 ->
	maybe_use_sharedinbox(user)

	true ->
	inbox
	end
	end

	@doc """
	Publishes an activity with BCC to all relevant peers.
	"""

	def publish(%User{} = actor, %{data: %{"bcc" => bcc}} = activity)
	when is_list(bcc) and bcc != [] do
	public = is_public?(activity)
	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)

	recipients = recipients(actor, activity)

	inboxes =
	recipients
	\|> Enum.filter(&User.ap_enabled?/1)
	\|> Enum.map(fn actor -> actor.inbox end)
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	\|> Instances.filter_reachable()

	Repo.checkout(fn ->
	Enum.each(inboxes, fn {inbox, unreachable_since} ->
	%User{ap_id: ap_id} = Enum.find(recipients, fn actor -> actor.inbox == inbox end)

	# Get all the recipients on the same host and add them to cc. Otherwise, a remote
	# instance would only accept a first message for the first recipient and ignore the rest.
	cc = get_cc_ap_ids(ap_id, recipients)

	json =
	data
	\|> Map.put("cc", cc)
	\|> Jason.encode!()

	Pleroma.Web.Federator.Publisher.enqueue_one(__MODULE__, %{
	inbox: inbox,
	json: json,
	actor_id: actor.id,
	id: activity.data["id"],
	unreachable_since: unreachable_since
	})
	end)
	end)
	end

	# Publishes an activity to all relevant peers.
	def publish(%User{} = actor, %Activity{} = activity) do
	public = is_public?(activity)

	if public && Config.get([:instance, :allow_relay]) do
	Logger.debug(fn -> "Relaying #{activity.data["id"]} out" end)
	Relay.publish(activity)
	end

	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
	json = Jason.encode!(data)

	recipients(actor, activity)
	\|> Enum.filter(fn user -> User.ap_enabled?(user) end)
	\|> Enum.map(fn %User{} = user ->
	determine_inbox(activity, user)
	end)
	\|> Enum.uniq()
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	\|> Instances.filter_reachable()
	\|> Enum.each(fn {inbox, unreachable_since} ->
	Pleroma.Web.Federator.Publisher.enqueue_one(
	__MODULE__,
	%{
	inbox: inbox,
	json: json,
	actor_id: actor.id,
	id: activity.data["id"],
	unreachable_since: unreachable_since
	}
	)
	end)
	end

	def gather_webfinger_links(%User{} = user) do
	[
	%{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
	%{
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"href" => user.ap_id
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	- "template" => "#{Pleroma.Web.base_url()}/ostatus_subscribe?acct={uri}"
	+ "template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
	}
	]
	end

	def gather_nodeinfo_protocol_names, do: ["activitypub"]
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index a4dc469dc..170dd9371 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,886 +1,886 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	import Ecto.Query

	require Logger
	require Pleroma.Constants

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

	# 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_list = extract_list(params["cc"])
	Map.put(params, "cc", [ap_id \| cc_list])
	else
	params
	end
	end

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	- "#{Web.base_url()}/schemas/litepub-0.1.jsonld",
	+ "#{Web.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
	- "#{Web.base_url()}/#{type}/#{UUID.generate()}"
	+ "#{Web.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 create_context(context) do
	context = context \|\| generate_id("contexts")

	# Ecto has problems accessing the constraint inside the jsonb,
	# so we explicitly check for the existed object before insert
	object = Object.get_cached_by_ap_id(context)

	with true <- is_nil(object),
	changeset <- Object.context_mapping(context),
	{:ok, inserted_object} <- Repo.insert(changeset) do
	inserted_object
	else
	_ ->
	object
	end
	end

	@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")
	\|> Map.put_new("context_id", -1)
	\|> lazy_put_object_defaults(true)
	end

	def lazy_put_activity_defaults(map, _fake?) do
	%{data: %{"id" => context}, id: context_id} = 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)
	\|> Map.put_new("context_id", context_id)
	\|> 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("context_id", activity["context_id"])
	\|> 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"])
	\|> Map.put_new("context_id", activity["context_id"])

	%{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}},
	object
	) do
	reactions = get_cached_emoji_reactions(object)

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

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

	count = emoji_count(new_reactions)

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

	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}},
	object
	) do
	reactions = get_cached_emoji_reactions(object)

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

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

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

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

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

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

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

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

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	@spec update_follow_state_for_all(Activity.t(), String.t()) :: {:ok, Activity \| nil}
	def update_follow_state_for_all(
	%Activity{data: %{"actor" => actor, "object" => object}} = activity,
	state
	) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> Activity.Queries.by_actor(actor)
	\|> Activity.Queries.by_object_id(object)
	\|> where(fragment("data->>'state' = 'pending'"))
	\|> 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)

	"EmojiReact"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^ap_id)
	\|> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
	\|> Activity.Queries.by_object_id(object_ap_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	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{data: %{"id" => id}, object: %{data: data}}) do
	activity_actor = User.get_by_ap_id(data["actor"])

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

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

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

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

	defp build_flag_object(_), do: []

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	defmodule Pleroma.Web.Feed.FeedView do
	use Phoenix.HTML
	use Pleroma.Web, :view

	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.MediaProxy

	require Pleroma.Constants

	@spec pub_date(String.t() \| DateTime.t()) :: String.t()
	def pub_date(date) when is_binary(date) do
	date
	\|> Timex.parse!("{ISO:Extended}")
	\|> pub_date
	end

	def pub_date(%DateTime{} = date), do: Timex.format!(date, "{RFC822}")

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

	actor =
	if opts[:actor] do
	Pleroma.User.get_cached_by_ap_id(activity.actor)
	end

	%{
	activity: activity,
	data: Map.get(object, :data),
	actor: actor
	}
	end

	def most_recent_update(activities) do
	with %{updated_at: updated_at} <- List.first(activities) do
	NaiveDateTime.to_iso8601(updated_at)
	end
	end

	def most_recent_update(activities, user) do
	(List.first(activities) \|\| user).updated_at
	\|> NaiveDateTime.to_iso8601()
	end

	def feed_logo do
	case Pleroma.Config.get([:feed, :logo]) do
	nil ->
	- "#{Pleroma.Web.base_url()}/static/logo.svg"
	+ "#{Pleroma.Web.Endpoint.url()}/static/logo.svg"

	logo ->
	- "#{Pleroma.Web.base_url()}#{logo}"
	+ "#{Pleroma.Web.Endpoint.url()}#{logo}"
	end
	\|> MediaProxy.url()
	end

	def logo(user) do
	user
	\|> User.avatar_url()
	\|> MediaProxy.url()
	end

	def last_activity(activities), do: List.last(activities)

	def activity_title(%{"content" => content}, opts \\ %{}) do
	content
	\|> Pleroma.Web.Metadata.Utils.scrub_html()
	\|> Pleroma.Emoji.Formatter.demojify()
	\|> Formatter.truncate(opts[:max_length], opts[:omission])
	\|> escape()
	end

	def activity_content(%{"content" => content}) do
	content
	\|> String.replace(~r/[\n\r]/, "")
	\|> escape()
	end

	def activity_content(_), do: ""

	def activity_context(activity), do: escape(activity.data["context"])

	def attachment_href(attachment) do
	attachment["url"]
	\|> hd()
	\|> Map.get("href")
	end

	def attachment_type(attachment) do
	attachment["url"]
	\|> hd()
	\|> Map.get("mediaType")
	end

	def get_href(id) do
	with %Object{data: %{"external_url" => external_url}} <- Object.get_cached_by_ap_id(id) do
	external_url
	else
	_e -> id
	end
	end

	def escape(html) do
	html
	\|> html_escape()
	\|> safe_to_string()
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/search_controller.ex b/lib/pleroma/web/mastodon_api/controllers/search_controller.ex
	index af93e453d..3d35e8fe0 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/search_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/search_controller.ex
	@@ -1,192 +1,192 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.SearchController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ControllerHelper
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter

	require Logger

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	# Note: Mastodon doesn't allow unauthenticated access (requires read:accounts / read:search)
	plug(OAuthScopesPlug, %{scopes: ["read:search"], fallback: :proceed_unauthenticated})

	# Note: on private instances auth is required (EnsurePublicOrAuthenticatedPlug is not skipped)

	plug(RateLimiter, [name: :search] when action in [:search, :search2, :account_search])

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

	def account_search(%{assigns: %{user: user}} = conn, %{q: query} = params) do
	accounts = User.search(query, search_options(params, user))

	conn
	\|> put_view(AccountView)
	\|> render("index.json",
	users: accounts,
	for: user,
	as: :user
	)
	end

	def search2(conn, params), do: do_search(:v2, conn, params)
	def search(conn, params), do: do_search(:v1, conn, params)

	defp do_search(version, %{assigns: %{user: user}} = conn, %{q: query} = params) do
	query = String.trim(query)
	options = search_options(params, user)
	timeout = Keyword.get(Repo.config(), :timeout, 15_000)
	default_values = %{"statuses" => [], "accounts" => [], "hashtags" => []}

	result =
	default_values
	\|> Enum.map(fn {resource, default_value} ->
	if params[:type] in [nil, resource] do
	{resource, fn -> resource_search(version, resource, query, options) end}
	else
	{resource, fn -> default_value end}
	end
	end)
	\|> Task.async_stream(fn {resource, f} -> {resource, with_fallback(f)} end,
	timeout: timeout,
	on_timeout: :kill_task
	)
	\|> Enum.reduce(default_values, fn
	{:ok, {resource, result}}, acc ->
	Map.put(acc, resource, result)

	_error, acc ->
	acc
	end)

	json(conn, result)
	end

	defp search_options(params, user) do
	[
	resolve: params[:resolve],
	following: params[:following],
	limit: params[:limit],
	offset: params[:offset],
	type: params[:type],
	author: get_author(params),
	embed_relationships: ControllerHelper.embed_relationships?(params),
	for_user: user
	]
	\|> Enum.filter(&elem(&1, 1))
	end

	defp resource_search(_, "accounts", query, options) do
	accounts = with_fallback(fn -> User.search(query, options) end)

	AccountView.render("index.json",
	users: accounts,
	for: options[:for_user],
	embed_relationships: options[:embed_relationships]
	)
	end

	defp resource_search(_, "statuses", query, options) do
	statuses = with_fallback(fn -> Activity.search(options[:for_user], query, options) end)

	StatusView.render("index.json",
	activities: statuses,
	for: options[:for_user],
	as: :activity
	)
	end

	defp resource_search(:v2, "hashtags", query, options) do
	- tags_path = Web.base_url() <> "/tag/"
	+ tags_path = Web.Endpoint.url() <> "/tag/"

	query
	\|> prepare_tags(options)
	\|> Enum.map(fn tag ->
	%{name: tag, url: tags_path <> tag}
	end)
	end

	defp resource_search(:v1, "hashtags", query, options) do
	prepare_tags(query, options)
	end

	defp prepare_tags(query, options) do
	tags =
	query
	\|> preprocess_uri_query()
	\|> String.split(~r/[^#\w]+/u, trim: true)
	\|> Enum.uniq_by(&String.downcase/1)

	explicit_tags = Enum.filter(tags, fn tag -> String.starts_with?(tag, "#") end)

	tags =
	if Enum.any?(explicit_tags) do
	explicit_tags
	else
	tags
	end

	tags = Enum.map(tags, fn tag -> String.trim_leading(tag, "#") end)

	tags =
	if Enum.empty?(explicit_tags) && !options[:skip_joined_tag] do
	add_joined_tag(tags)
	else
	tags
	end

	Pleroma.Pagination.paginate(tags, options)
	end

	defp add_joined_tag(tags) do
	tags
	\|> Kernel.++([joined_tag(tags)])
	\|> Enum.uniq_by(&String.downcase/1)
	end

	# If `query` is a URI, returns last component of its path, otherwise returns `query`
	defp preprocess_uri_query(query) do
	if query =~ ~r/https?:\/\// do
	query
	\|> String.trim_trailing("/")
	\|> URI.parse()
	\|> Map.get(:path)
	\|> String.split("/")
	\|> Enum.at(-1)
	else
	query
	end
	end

	defp joined_tag(tags) do
	tags
	\|> Enum.map(fn tag -> String.capitalize(tag) end)
	\|> Enum.join()
	end

	defp with_fallback(f, fallback \\ []) do
	try do
	f.()
	rescue
	error ->
	Logger.error("#{__MODULE__} search error: #{inspect(error)}")
	fallback
	end
	end

	defp get_author(%{account_id: account_id}) when is_binary(account_id),
	do: User.get_cached_by_id(account_id)

	defp get_author(_params), do: nil
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex b/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	index 40e314164..c8f076712 100644
	--- a/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/custom_emoji_view.ex
	@@ -1,28 +1,28 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Emoji
	alias Pleroma.Web

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

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

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

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

	alias Pleroma.Config
	alias Pleroma.Web.ActivityPub.MRF

	@mastodon_api_level "2.7.2"

	def render("show.json", _) do
	instance = Config.get(:instance)

	%{
	- uri: Pleroma.Web.base_url(),
	+ uri: Pleroma.Web.Endpoint.url(),
	title: Keyword.get(instance, :name),
	description: Keyword.get(instance, :description),
	version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})",
	email: Keyword.get(instance, :email),
	urls: %{
	streaming_api: Pleroma.Web.Endpoint.websocket_url()
	},
	stats: Pleroma.Stats.get_stats(),
	- thumbnail: Pleroma.Web.base_url() <> Keyword.get(instance, :instance_thumbnail),
	+ thumbnail: Pleroma.Web.Endpoint.url() <> Keyword.get(instance, :instance_thumbnail),
	languages: ["en"],
	registrations: Keyword.get(instance, :registrations_open),
	approval_required: Keyword.get(instance, :account_approval_required),
	# Extra (not present in Mastodon):
	max_toot_chars: Keyword.get(instance, :limit),
	poll_limits: Keyword.get(instance, :poll_limits),
	upload_limit: Keyword.get(instance, :upload_limit),
	avatar_upload_limit: Keyword.get(instance, :avatar_upload_limit),
	background_upload_limit: Keyword.get(instance, :background_upload_limit),
	banner_upload_limit: Keyword.get(instance, :banner_upload_limit),
	- background_image: Pleroma.Web.base_url() <> Keyword.get(instance, :background_image),
	+ background_image: Pleroma.Web.Endpoint.url() <> Keyword.get(instance, :background_image),
	chat_limit: Keyword.get(instance, :chat_limit),
	description_limit: Keyword.get(instance, :description_limit),
	pleroma: %{
	metadata: %{
	account_activation_required: Keyword.get(instance, :account_activation_required),
	features: features(),
	federation: federation(),
	fields_limits: fields_limits(),
	post_formats: Config.get([:instance, :allowed_post_formats])
	},
	stats: %{mau: Pleroma.User.active_user_count()},
	vapid_public_key: Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
	}
	}
	end

	def features do
	[
	"pleroma_api",
	"mastodon_api",
	"mastodon_api_streaming",
	"polls",
	"pleroma_explicit_addressing",
	"shareable_emoji_packs",
	"multifetch",
	"pleroma:api/v1/notifications:include_types_filter",
	if Config.get([:media_proxy, :enabled]) do
	"media_proxy"
	end,
	if Config.get([:gopher, :enabled]) do
	"gopher"
	end,
	if Config.get([:chat, :enabled]) do
	"chat"
	end,
	if Config.get([:instance, :allow_relay]) do
	"relay"
	end,
	if Config.get([:instance, :safe_dm_mentions]) do
	"safe_dm_mentions"
	end,
	"pleroma_emoji_reactions",
	"pleroma_chat_messages"
	]
	\|> Enum.filter(& &1)
	end

	def federation do
	quarantined = Config.get([:instance, :quarantined_instances], [])

	if Config.get([:mrf, :transparency]) do
	{:ok, data} = MRF.describe()

	data
	\|> Map.merge(%{quarantined_instances: quarantined})
	else
	%{}
	end
	\|> Map.put(:enabled, Config.get([:instance, :federating]))
	end

	def fields_limits do
	%{
	max_fields: Config.get([:instance, :max_account_fields]),
	max_remote_fields: Config.get([:instance, :max_remote_account_fields]),
	name_length: Config.get([:instance, :account_field_name_length]),
	value_length: Config.get([:instance, :account_field_value_length])
	}
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index bac897a57..9e06c5e95 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,541 +1,541 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	require Pleroma.Constants

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

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

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

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

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

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

	defp get_context_id(%{data: %{"context_id" => context_id}}) when not is_nil(context_id),
	do: context_id

	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
	do: Utils.context_to_conversation_id(context)

	defp get_context_id(_), do: nil

	defp reblogged?(activity, user) do
	object = Object.normalize(activity, fetch: false) \|\| %{}
	present?(user && user.ap_id in (object.data["announcements"] \|\| []))
	end

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

	# To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
	activities = Enum.filter(opts.activities, & &1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	reply_to = get_reply_to(activity, opts)

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

	content =
	object
	\|> render_content()

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

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

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

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

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

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

	_e ->
	nil
	end

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

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

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

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

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

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

	page_url = page_url_data \|> to_string

	image_url =
	if is_binary(rich_media["image"]) do
	URI.merge(page_url_data, URI.parse(rich_media["image"]))
	\|> to_string
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	@doc """
	Builds a dictionary tags.

	## Examples

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

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

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

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

	Returns list emojis.

	## Examples

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

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

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

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

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

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

	defp pinned?(%Activity{id: id}, %User{pinned_activities: pinned_activities}),
	do: id in pinned_activities

	defp build_emoji_map(emoji, users, current_user) do
	%{
	name: emoji,
	count: length(users),
	me: !!(current_user && current_user.ap_id in users)
	}
	end

	@spec build_application(map() \| nil) :: map() \| nil
	defp build_application(%{type: _type, name: name, url: url}), do: %{name: name, website: url}
	defp build_application(_), do: nil
	end
	diff --git a/lib/pleroma/web/media_proxy.ex b/lib/pleroma/web/media_proxy.ex
	index 27f337138..d19066a10 100644
	--- a/lib/pleroma/web/media_proxy.ex
	+++ b/lib/pleroma/web/media_proxy.ex
	@@ -1,181 +1,181 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy do
	alias Pleroma.Config
	alias Pleroma.Helpers.UriHelper
	alias Pleroma.Upload
	alias Pleroma.Web
	alias Pleroma.Web.MediaProxy.Invalidation

	@base64_opts [padding: false]
	@cache_table :banned_urls_cache

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

	def cache_table, do: @cache_table

	@spec in_banned_urls(String.t()) :: boolean()
	def in_banned_urls(url), do: elem(@cachex.exists?(@cache_table, url(url)), 1)

	def remove_from_banned_urls(urls) when is_list(urls) do
	@cachex.execute!(@cache_table, fn cache ->
	Enum.each(Invalidation.prepare_urls(urls), &@cachex.del(cache, &1))
	end)
	end

	def remove_from_banned_urls(url) when is_binary(url) do
	@cachex.del(@cache_table, url(url))
	end

	def put_in_banned_urls(urls) when is_list(urls) do
	@cachex.execute!(@cache_table, fn cache ->
	Enum.each(Invalidation.prepare_urls(urls), &@cachex.put(cache, &1, true))
	end)
	end

	def put_in_banned_urls(url) when is_binary(url) do
	@cachex.put(@cache_table, url(url), true)
	end

	def url(url) when is_nil(url) or url == "", do: nil
	def url("/" <> _ = url), do: url

	def url(url) do
	if enabled?() and url_proxiable?(url) do
	encode_url(url)
	else
	url
	end
	end

	@spec url_proxiable?(String.t()) :: boolean()
	def url_proxiable?(url) do
	not local?(url) and not whitelisted?(url)
	end

	def preview_url(url, preview_params \\ []) do
	if preview_enabled?() do
	encode_preview_url(url, preview_params)
	else
	url(url)
	end
	end

	def enabled?, do: Config.get([:media_proxy, :enabled], false)

	# Note: media proxy must be enabled for media preview proxy in order to load all
	# non-local non-whitelisted URLs through it and be sure that body size constraint is preserved.
	def preview_enabled?, do: enabled?() and !!Config.get([:media_preview_proxy, :enabled])

	- def local?(url), do: String.starts_with?(url, Web.base_url())
	+ def local?(url), do: String.starts_with?(url, Web.Endpoint.url())

	def whitelisted?(url) do
	%{host: domain} = URI.parse(url)

	mediaproxy_whitelist_domains =
	[:media_proxy, :whitelist]
	\|> Config.get()
	\|> Kernel.++(["#{Upload.base_url()}"])
	\|> Enum.map(&maybe_get_domain_from_url/1)

	domain in mediaproxy_whitelist_domains
	end

	defp maybe_get_domain_from_url("http" <> _ = url) do
	URI.parse(url).host
	end

	defp maybe_get_domain_from_url(domain), do: domain

	defp base64_sig64(url) do
	base64 = Base.url_encode64(url, @base64_opts)

	sig64 =
	base64
	\|> signed_url()
	\|> Base.url_encode64(@base64_opts)

	{base64, sig64}
	end

	def encode_url(url) do
	{base64, sig64} = base64_sig64(url)

	build_url(sig64, base64, filename(url))
	end

	def encode_preview_url(url, preview_params \\ []) do
	{base64, sig64} = base64_sig64(url)

	build_preview_url(sig64, base64, filename(url), preview_params)
	end

	def decode_url(sig, url) do
	with {:ok, sig} <- Base.url_decode64(sig, @base64_opts),
	signature when signature == sig <- signed_url(url) do
	{:ok, Base.url_decode64!(url, @base64_opts)}
	else
	_ -> {:error, :invalid_signature}
	end
	end

	defp signed_url(url) do
	:crypto.hmac(:sha, Config.get([Web.Endpoint, :secret_key_base]), url)
	end

	def filename(url_or_path) do
	if path = URI.parse(url_or_path).path, do: Path.basename(path)
	end

	def base_url do
	- Config.get([:media_proxy, :base_url], Web.base_url())
	+ Config.get([:media_proxy, :base_url], Web.Endpoint.url())
	end

	defp proxy_url(path, sig_base64, url_base64, filename) do
	[
	base_url(),
	path,
	sig_base64,
	url_base64,
	filename
	]
	\|> Enum.filter(& &1)
	\|> Path.join()
	end

	def build_url(sig_base64, url_base64, filename \\ nil) do
	proxy_url("proxy", sig_base64, url_base64, filename)
	end

	def build_preview_url(sig_base64, url_base64, filename \\ nil, preview_params \\ []) do
	uri = proxy_url("proxy/preview", sig_base64, url_base64, filename)

	UriHelper.modify_uri_params(uri, preview_params)
	end

	def verify_request_path_and_url(
	%Plug.Conn{params: %{"filename" => _}, request_path: request_path},
	url
	) do
	verify_request_path_and_url(request_path, url)
	end

	def verify_request_path_and_url(request_path, url) when is_binary(request_path) do
	filename = filename(url)

	if filename && not basename_matches?(request_path, filename) do
	{:wrong_filename, filename}
	else
	:ok
	end
	end

	def verify_request_path_and_url(_, _), do: :ok

	defp basename_matches?(path, filename) do
	basename = Path.basename(path)
	basename == filename or URI.decode(basename) == filename or URI.encode(basename) == filename
	end
	end
	diff --git a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	index bca94d236..a3ae01c74 100644
	--- a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	+++ b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	@@ -1,44 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Nodeinfo.NodeinfoController do
	use Pleroma.Web, :controller

	alias Pleroma.Web
	alias Pleroma.Web.Nodeinfo.Nodeinfo

	def schemas(conn, _params) do
	response = %{
	links: [
	%{
	rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
	- href: Web.base_url() <> "/nodeinfo/2.0.json"
	+ href: Web.Endpoint.url() <> "/nodeinfo/2.0.json"
	},
	%{
	rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
	- href: Web.base_url() <> "/nodeinfo/2.1.json"
	+ href: Web.Endpoint.url() <> "/nodeinfo/2.1.json"
	}
	]
	}

	json(conn, response)
	end

	# Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.0/schema.json
	# and https://github.com/jhass/nodeinfo/blob/master/schemas/2.1/schema.json
	def nodeinfo(conn, %{"version" => version}) do
	case Nodeinfo.get_nodeinfo(version) do
	{:error, :missing} ->
	render_error(conn, :not_found, "Nodeinfo schema version not handled")

	node_info ->
	conn
	\|> put_resp_header(
	"content-type",
	"application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.0#; charset=utf-8"
	)
	\|> json(node_info)
	end
	end
	end
	diff --git a/lib/pleroma/web/templates/feed/feed/_activity.atom.eex b/lib/pleroma/web/templates/feed/feed/_activity.atom.eex
	index 3fd150c4e..ca31223fc 100644
	--- a/lib/pleroma/web/templates/feed/feed/_activity.atom.eex
	+++ b/lib/pleroma/web/templates/feed/feed/_activity.atom.eex
	@@ -1,50 +1,50 @@
	<entry>
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>
	<id><%= @data["id"] %></id>
	<title><%= activity_title(@data, Keyword.get(@feed_config, :post_title, %{})) %></title>
	<content type="html"><%= activity_content(@data) %></content>
	<published><%= @activity.data["published"] %></published>
	<updated><%= @activity.data["published"] %></updated>
	<ostatus:conversation ref="<%= activity_context(@activity) %>">
	<%= activity_context(@activity) %>
	</ostatus:conversation>
	<link href="<%= activity_context(@activity) %>" rel="ostatus:conversation"/>

	<%= if @data["summary"] do %>
	<summary><%= escape(@data["summary"]) %></summary>
	<% end %>

	<%= if @activity.local do %>
	<link type="application/atom+xml" href='<%= @data["id"] %>' rel="self"/>
	<link type="text/html" href='<%= @data["id"] %>' rel="alternate"/>
	<% else %>
	<link type="text/html" href='<%= @data["external_url"] %>' rel="alternate"/>
	<% end %>

	<%= for tag <- @data["tag"] \|\| [] do %>
	<category term="<%= tag %>"></category>
	<% end %>

	<%= for attachment <- @data["attachment"] \|\| [] do %>
	<link rel="enclosure" href="<%= attachment_href(attachment) %>" type="<%= attachment_type(attachment) %>"/>
	<% end %>

	<%= if @data["inReplyTo"] do %>
	<thr:in-reply-to ref='<%= @data["inReplyTo"] %>' href='<%= get_href(@data["inReplyTo"]) %>'/>
	<% end %>

	<%= for id <- @activity.recipients do %>
	<%= if id == Pleroma.Constants.as_public() do %>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	<% else %>
	- <%= unless Regex.match?(~r/^#{Pleroma.Web.base_url()}.+followers$/, id) do %>
	+ <%= unless Regex.match?(~r/^#{Pleroma.Web.Endpoint.url()}.+followers$/, id) do %>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person" href="<%= id %>"/>
	<% end %>
	<% end %>
	<% end %>

	<%= for {emoji, file} <- @data["emoji"] \|\| %{} do %>
	<link name="<%= emoji %>" rel="emoji" href="<%= file %>"/>
	<% end %>
	</entry>
	diff --git a/lib/pleroma/web/templates/feed/feed/_activity.rss.eex b/lib/pleroma/web/templates/feed/feed/_activity.rss.eex
	index 947bbb099..01dddba07 100644
	--- a/lib/pleroma/web/templates/feed/feed/_activity.rss.eex
	+++ b/lib/pleroma/web/templates/feed/feed/_activity.rss.eex
	@@ -1,50 +1,50 @@
	<item>
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>
	<guid><%= @data["id"] %></guid>
	<title><%= activity_title(@data, Keyword.get(@feed_config, :post_title, %{})) %></title>
	<description><%= activity_content(@data) %></description>
	<pubDate><%= @activity.data["published"] %></pubDate>
	<updated><%= @activity.data["published"] %></updated>
	<ostatus:conversation ref="<%= activity_context(@activity) %>">
	<%= activity_context(@activity) %>
	</ostatus:conversation>

	<%= if @data["summary"] do %>
	<description><%= escape(@data["summary"]) %></description>
	<% end %>

	<%= if @activity.local do %>
	<link><%= @data["id"] %></link>
	<% else %>
	<link><%= @data["external_url"] %></link>
	<% end %>

	<link rel="ostatus:conversation"><%= activity_context(@activity) %></link>

	<%= for tag <- @data["tag"] \|\| [] do %>
	<category term="<%= tag %>"></category>
	<% end %>

	<%= for attachment <- @data["attachment"] \|\| [] do %>
	<link type="<%= attachment_type(attachment) %>"><%= attachment_href(attachment) %></link>
	<% end %>

	<%= if @data["inReplyTo"] do %>
	<thr:in-reply-to ref='<%= @data["inReplyTo"] %>' href='<%= get_href(@data["inReplyTo"]) %>'/>
	<% end %>

	<%= for id <- @activity.recipients do %>
	<%= if id == Pleroma.Constants.as_public() do %>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection">http://activityschema.org/collection/public</link>
	<% else %>
	- <%= unless Regex.match?(~r/^#{Pleroma.Web.base_url()}.+followers$/, id) do %>
	+ <%= unless Regex.match?(~r/^#{Pleroma.Web.Endpoint.url()}.+followers$/, id) do %>
	<link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/person"><%= id %></link>
	<% end %>
	<% end %>
	<% end %>

	<%= for {emoji, file} <- @data["emoji"] \|\| %{} do %>
	<link name="<%= emoji %>" rel="emoji"><%= file %></link>
	<% end %>
	</item>
	diff --git a/lib/pleroma/web/templates/feed/feed/_tag_activity.atom.eex b/lib/pleroma/web/templates/feed/feed/_tag_activity.atom.eex
	index cf5874a91..9ae28b48a 100644
	--- a/lib/pleroma/web/templates/feed/feed/_tag_activity.atom.eex
	+++ b/lib/pleroma/web/templates/feed/feed/_tag_activity.atom.eex
	@@ -1,51 +1,51 @@
	<entry>
	<activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	<activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>

	<%= render @view_module, "_tag_author.atom", assigns %>

	<id><%= @data["id"] %></id>
	<title><%= activity_title(@data, Keyword.get(@feed_config, :post_title, %{})) %></title>
	<content type="html"><%= activity_content(@data) %></content>

	<%= if @activity.local do %>
	<link type="application/atom+xml" href='<%= @data["id"] %>' rel="self"/>
	<link type="text/html" href='<%= @data["id"] %>' rel="alternate"/>
	<% else %>
	<link type="text/html" href='<%= @data["external_url"] %>' rel="alternate"/>
	<% end %>

	<published><%= @activity.data["published"] %></published>
	<updated><%= @activity.data["published"] %></updated>

	<ostatus:conversation ref="<%= activity_context(@activity) %>">
	<%= activity_context(@activity) %>
	</ostatus:conversation>
	<link href="<%= activity_context(@activity) %>" rel="ostatus:conversation"/>

	<%= if @data["summary"] do %>
	<summary><%= @data["summary"] %></summary>
	<% end %>

	<%= for id <- @activity.recipients do %>
	<%= if id == Pleroma.Constants.as_public() do %>
	<link rel="mentioned"
	ostatus:object-type="http://activitystrea.ms/schema/1.0/collection"
	href="http://activityschema.org/collection/public"/>
	<% else %>
	- <%= unless Regex.match?(~r/^#{Pleroma.Web.base_url()}.+followers$/, id) do %>
	+ <%= unless Regex.match?(~r/^#{Pleroma.Web.Endpoint.url()}.+followers$/, id) do %>
	<link rel="mentioned"
	ostatus:object-type="http://activitystrea.ms/schema/1.0/person"
	href="<%= id %>" />
	<% end %>
	<% end %>
	<% end %>

	<%= for tag <- @data["tag"] \|\| [] do %>
	<category term="<%= tag %>"></category>
	<% end %>

	<%= for {emoji, file} <- @data["emoji"] \|\| %{} do %>
	<link name="<%= emoji %>" rel="emoji" href="<%= file %>"/>
	<% end %>
	</entry>
	diff --git a/lib/pleroma/web/templates/twitter_api/password/reset_failed.html.eex b/lib/pleroma/web/templates/twitter_api/password/reset_failed.html.eex
	index df037c01e..4ed4ac8bc 100644
	--- a/lib/pleroma/web/templates/twitter_api/password/reset_failed.html.eex
	+++ b/lib/pleroma/web/templates/twitter_api/password/reset_failed.html.eex
	@@ -1,2 +1,2 @@
	<h2>Password reset failed</h2>
	-<h3><a href="<%= Pleroma.Web.base_url() %>">Homepage</a></h3>
	+<h3><a href="<%= Pleroma.Web.Endpoint.url() %>">Homepage</a></h3>
	diff --git a/lib/pleroma/web/templates/twitter_api/password/reset_success.html.eex b/lib/pleroma/web/templates/twitter_api/password/reset_success.html.eex
	index f30ba3274..086d4e08b 100644
	--- a/lib/pleroma/web/templates/twitter_api/password/reset_success.html.eex
	+++ b/lib/pleroma/web/templates/twitter_api/password/reset_success.html.eex
	@@ -1,2 +1,2 @@
	<h2>Password changed!</h2>
	-<h3><a href="<%= Pleroma.Web.base_url() %>">Homepage</a></h3>
	+<h3><a href="<%= Pleroma.Web.Endpoint.url() %>">Homepage</a></h3>
	diff --git a/lib/pleroma/web/twitter_api/views/util_view.ex b/lib/pleroma/web/twitter_api/views/util_view.ex
	index 9b13c09b3..70b27b5cf 100644
	--- a/lib/pleroma/web/twitter_api/views/util_view.ex
	+++ b/lib/pleroma/web/twitter_api/views/util_view.ex
	@@ -1,28 +1,28 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilView do
	use Pleroma.Web, :view
	import Phoenix.HTML.Form
	alias Pleroma.Config
	alias Pleroma.Web

	def status_net_config(instance) do
	"""
	<config>
	<site>
	<name>#{Keyword.get(instance, :name)}</name>
	- <site>#{Web.base_url()}</site>
	+ <site>#{Web.Endpoint.url()}</site>
	<textlimit>#{Keyword.get(instance, :limit)}</textlimit>
	<closed>#{!Keyword.get(instance, :registrations_open)}</closed>
	</site>
	</config>
	"""
	end

	def render("frontend_configurations.json", _) do
	Config.get(:frontend_configurations, %{})
	\|> Enum.into(%{})
	end
	end
	diff --git a/lib/pleroma/web/views/masto_fe_view.ex b/lib/pleroma/web/views/masto_fe_view.ex
	index 82b301949..63a9c8179 100644
	--- a/lib/pleroma/web/views/masto_fe_view.ex
	+++ b/lib/pleroma/web/views/masto_fe_view.ex
	@@ -1,91 +1,91 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastoFEView do
	use Pleroma.Web, :view
	alias Pleroma.Config
	alias Pleroma.User
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.CustomEmojiView

	def initial_state(token, user, custom_emojis) do
	limit = Config.get([:instance, :limit])

	%{
	meta: %{
	streaming_api_base_url: Pleroma.Web.Endpoint.websocket_url(),
	access_token: token,
	locale: "en",
	domain: Pleroma.Web.Endpoint.host(),
	admin: "1",
	me: "#{user.id}",
	unfollow_modal: false,
	boost_modal: false,
	delete_modal: true,
	auto_play_gif: false,
	display_sensitive_media: false,
	reduce_motion: false,
	max_toot_chars: limit,
	mascot: User.get_mascot(user)["url"]
	},
	poll_limits: Config.get([:instance, :poll_limits]),
	rights: %{
	delete_others_notice: present?(user.is_moderator),
	admin: present?(user.is_admin)
	},
	compose: %{
	me: "#{user.id}",
	default_privacy: user.default_scope,
	default_sensitive: false,
	allow_content_types: Config.get([:instance, :allowed_post_formats])
	},
	media_attachments: %{
	accept_content_types: [
	".jpg",
	".jpeg",
	".png",
	".gif",
	".webm",
	".mp4",
	".m4v",
	"image\/jpeg",
	"image\/png",
	"image\/gif",
	"video\/webm",
	"video\/mp4"
	]
	},
	settings: user.mastofe_settings \|\| %{},
	push_subscription: nil,
	accounts: %{user.id => render(AccountView, "show.json", user: user, for: user)},
	custom_emojis: render(CustomEmojiView, "index.json", custom_emojis: custom_emojis),
	char_limit: limit
	}
	\|> Jason.encode!()
	\|> Phoenix.HTML.raw()
	end

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

	def render("manifest.json", _params) do
	%{
	name: Config.get([:instance, :name]),
	description: Config.get([:instance, :description]),
	icons: Config.get([:manifest, :icons]),
	theme_color: Config.get([:manifest, :theme_color]),
	background_color: Config.get([:manifest, :background_color]),
	display: "standalone",
	- scope: Pleroma.Web.base_url(),
	+ scope: Pleroma.Web.Endpoint.url(),
	start_url: Routes.masto_fe_path(Pleroma.Web.Endpoint, :index, ["getting-started"]),
	categories: [
	"social"
	],
	serviceworker: %{
	src: "/sw.js"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/web_finger.ex b/lib/pleroma/web/web_finger.ex
	index 15002b29f..5aff37057 100644
	--- a/lib/pleroma/web/web_finger.ex
	+++ b/lib/pleroma/web/web_finger.ex
	@@ -1,212 +1,212 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFinger do
	alias Pleroma.HTTP
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.Federator.Publisher
	alias Pleroma.Web.XML
	alias Pleroma.XmlBuilder
	require Jason
	require Logger

	def host_meta do
	- base_url = Web.base_url()
	+ base_url = Web.Endpoint.url()

	{
	:XRD,
	%{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	{
	:Link,
	%{
	rel: "lrdd",
	type: "application/xrd+xml",
	template: "#{base_url}/.well-known/webfinger?resource={uri}"
	}
	}
	}
	\|> XmlBuilder.to_doc()
	end

	def webfinger(resource, fmt) when fmt in ["XML", "JSON"] do
	host = Pleroma.Web.Endpoint.host()
	regex = ~r/(acct:)?(?<username>[a-z0-9A-Z_\.-]+)@#{host}/

	with %{"username" => username} <- Regex.named_captures(regex, resource),
	%User{} = user <- User.get_cached_by_nickname(username) do
	{:ok, represent_user(user, fmt)}
	else
	_e ->
	with %User{} = user <- User.get_cached_by_ap_id(resource) do
	{:ok, represent_user(user, fmt)}
	else
	_e ->
	{:error, "Couldn't find user"}
	end
	end
	end

	defp gather_links(%User{} = user) do
	[
	%{
	"rel" => "http://webfinger.net/rel/profile-page",
	"type" => "text/html",
	"href" => user.ap_id
	}
	] ++ Publisher.gather_webfinger_links(user)
	end

	defp gather_aliases(%User{} = user) do
	[user.ap_id \| user.also_known_as]
	end

	def represent_user(user, "JSON") do
	{:ok, user} = User.ensure_keys_present(user)

	%{
	"subject" => "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host()}",
	"aliases" => gather_aliases(user),
	"links" => gather_links(user)
	}
	end

	def represent_user(user, "XML") do
	{:ok, user} = User.ensure_keys_present(user)

	aliases =
	user
	\|> gather_aliases()
	\|> Enum.map(&{:Alias, &1})

	links =
	gather_links(user)
	\|> Enum.map(fn link -> {:Link, link} end)

	{
	:XRD,
	%{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	[
	{:Subject, "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host()}"}
	] ++ aliases ++ links
	}
	\|> XmlBuilder.to_doc()
	end

	defp webfinger_from_xml(doc) do
	subject = XML.string_from_xpath("//Subject", doc)

	subscribe_address =
	~s{//Link[@rel="http://ostatus.org/schema/1.0/subscribe"]/@template}
	\|> XML.string_from_xpath(doc)

	ap_id =
	~s{//Link[@rel="self" and @type="application/activity+json"]/@href}
	\|> XML.string_from_xpath(doc)

	data = %{
	"subject" => subject,
	"subscribe_address" => subscribe_address,
	"ap_id" => ap_id
	}

	{:ok, data}
	end

	defp webfinger_from_json(doc) do
	data =
	Enum.reduce(doc["links"], %{"subject" => doc["subject"]}, fn link, data ->
	case {link["type"], link["rel"]} do
	{"application/activity+json", "self"} ->
	Map.put(data, "ap_id", link["href"])

	{"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"", "self"} ->
	Map.put(data, "ap_id", link["href"])

	{nil, "http://ostatus.org/schema/1.0/subscribe"} ->
	Map.put(data, "subscribe_address", link["template"])

	_ ->
	Logger.debug("Unhandled type: #{inspect(link["type"])}")
	data
	end
	end)

	{:ok, data}
	end

	def get_template_from_xml(body) do
	xpath = "//Link[@rel='lrdd']/@template"

	with doc when doc != :error <- XML.parse_document(body),
	template when template != nil <- XML.string_from_xpath(xpath, doc) do
	{:ok, template}
	end
	end

	def find_lrdd_template(domain) do
	with {:ok, %{status: status, body: body}} when status in 200..299 <-
	HTTP.get("http://#{domain}/.well-known/host-meta") do
	get_template_from_xml(body)
	else
	_ ->
	with {:ok, %{body: body, status: status}} when status in 200..299 <-
	HTTP.get("https://#{domain}/.well-known/host-meta") do
	get_template_from_xml(body)
	else
	e -> {:error, "Can't find LRDD template: #{inspect(e)}"}
	end
	end
	end

	defp get_address_from_domain(domain, encoded_account) when is_binary(domain) do
	case find_lrdd_template(domain) do
	{:ok, template} ->
	String.replace(template, "{uri}", encoded_account)

	_ ->
	"https://#{domain}/.well-known/webfinger?resource=#{encoded_account}"
	end
	end

	defp get_address_from_domain(_, _), do: nil

	@spec finger(String.t()) :: {:ok, map()} \| {:error, any()}
	def finger(account) do
	account = String.trim_leading(account, "@")

	domain =
	with [_name, domain] <- String.split(account, "@") do
	domain
	else
	_e ->
	URI.parse(account).host
	end

	encoded_account = URI.encode("acct:#{account}")

	with address when is_binary(address) <- get_address_from_domain(domain, encoded_account),
	response <-
	HTTP.get(
	address,
	[{"accept", "application/xrd+xml,application/jrd+json"}]
	),
	{:ok, %{status: status, body: body}} when status in 200..299 <- response do
	doc = XML.parse_document(body)

	if doc != :error do
	webfinger_from_xml(doc)
	else
	with {:ok, doc} <- Jason.decode(body) do
	webfinger_from_json(doc)
	end
	end
	else
	e ->
	Logger.debug(fn -> "Couldn't finger #{account}" end)
	Logger.debug(fn -> inspect(e) end)
	{:error, e}
	end
	end
	end
	diff --git a/test/pleroma/user_test.exs b/test/pleroma/user_test.exs
	index 6f5bcab57..79c7d7ed1 100644
	--- a/test/pleroma/user_test.exs
	+++ b/test/pleroma/user_test.exs
	@@ -1,2341 +1,2341 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserTest do
	alias Pleroma.Activity
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Swoosh.TestAssertions

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

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

	describe "service actors" do
	test "returns updated invisible actor" do
	uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	followers_uri = "#{uri}/followers"

	insert(
	:user,
	%{
	nickname: "relay",
	invisible: false,
	local: true,
	ap_id: uri,
	follower_address: followers_uri
	}
	)

	actor = User.get_or_create_service_actor_by_ap_id(uri, "relay")
	assert actor.invisible
	end

	test "returns relay user" do
	uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	followers_uri = "#{uri}/followers"

	assert %User{
	nickname: "relay",
	invisible: true,
	local: true,
	ap_id: ^uri,
	follower_address: ^followers_uri
	} = User.get_or_create_service_actor_by_ap_id(uri, "relay")

	assert capture_log(fn ->
	refute User.get_or_create_service_actor_by_ap_id("/relay", "relay")
	end) =~ "Cannot create service actor:"
	end

	test "returns invisible actor" do
	uri = "#{Pleroma.Web.Endpoint.url()}/internal/fetch-test"
	followers_uri = "#{uri}/followers"
	user = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")

	assert %User{
	nickname: "internal.fetch-test",
	invisible: true,
	local: true,
	ap_id: ^uri,
	follower_address: ^followers_uri
	} = user

	user2 = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")
	assert user.id == user2.id
	end
	end

	describe "AP ID user relationships" do
	setup do
	{:ok, user: insert(:user)}
	end

	test "outgoing_relationships_ap_ids/1", %{user: user} do
	rel_types = [:block, :mute, :notification_mute, :reblog_mute, :inverse_subscription]

	ap_ids_by_rel =
	Enum.into(
	rel_types,
	%{},
	fn rel_type ->
	rel_records =
	insert_list(2, :user_relationship, %{source: user, relationship_type: rel_type})

	ap_ids = Enum.map(rel_records, fn rr -> Repo.preload(rr, :target).target.ap_id end)
	{rel_type, Enum.sort(ap_ids)}
	end
	)

	assert ap_ids_by_rel[:block] == Enum.sort(User.blocked_users_ap_ids(user))
	assert ap_ids_by_rel[:block] == Enum.sort(Enum.map(User.blocked_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:mute] == Enum.sort(User.muted_users_ap_ids(user))
	assert ap_ids_by_rel[:mute] == Enum.sort(Enum.map(User.muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:notification_mute] ==
	Enum.sort(User.notification_muted_users_ap_ids(user))

	assert ap_ids_by_rel[:notification_mute] ==
	Enum.sort(Enum.map(User.notification_muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:reblog_mute] == Enum.sort(User.reblog_muted_users_ap_ids(user))

	assert ap_ids_by_rel[:reblog_mute] ==
	Enum.sort(Enum.map(User.reblog_muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:inverse_subscription] == Enum.sort(User.subscriber_users_ap_ids(user))

	assert ap_ids_by_rel[:inverse_subscription] ==
	Enum.sort(Enum.map(User.subscriber_users(user), & &1.ap_id))

	outgoing_relationships_ap_ids = User.outgoing_relationships_ap_ids(user, rel_types)

	assert ap_ids_by_rel ==
	Enum.into(outgoing_relationships_ap_ids, %{}, fn {k, v} -> {k, Enum.sort(v)} end)
	end
	end

	describe "when tags are nil" do
	test "tagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.tag(user, ["cool", "dude"])

	assert "cool" in user.tags
	assert "dude" in user.tags
	end

	test "untagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.untag(user, ["cool", "dude"])

	assert user.tags == []
	end
	end

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	- expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"
	+ expected_ap_id = "#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "ap_following returns the following collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/following"

	assert expected_followers_collection == User.ap_following(user)
	end

	test "returns all pending follow requests" do
	unlocked = insert(:user)
	locked = insert(:user, is_locked: true)
	follower = insert(:user)

	CommonAPI.follow(follower, unlocked)
	CommonAPI.follow(follower, locked)

	assert [] = User.get_follow_requests(unlocked)
	assert [activity] = User.get_follow_requests(locked)

	assert activity
	end

	test "doesn't return already accepted or duplicate follow requests" do
	locked = insert(:user, is_locked: true)
	pending_follower = insert(:user)
	accepted_follower = insert(:user)

	CommonAPI.follow(pending_follower, locked)
	CommonAPI.follow(pending_follower, locked)
	CommonAPI.follow(accepted_follower, locked)

	Pleroma.FollowingRelationship.update(accepted_follower, locked, :follow_accept)

	assert [^pending_follower] = User.get_follow_requests(locked)
	end

	test "doesn't return follow requests for deactivated accounts" do
	locked = insert(:user, is_locked: true)
	pending_follower = insert(:user, %{is_active: false})

	CommonAPI.follow(pending_follower, locked)

	refute pending_follower.is_active
	assert [] = User.get_follow_requests(locked)
	end

	test "clears follow requests when requester is blocked" do
	followed = insert(:user, is_locked: true)
	follower = insert(:user)

	CommonAPI.follow(follower, followed)
	assert [_activity] = User.get_follow_requests(followed)

	{:ok, _user_relationship} = User.block(followed, follower)
	assert [] = User.get_follow_requests(followed)
	end

	test "follow_all follows mutliple users" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	blocked = insert(:user)
	not_followed = insert(:user)
	reverse_blocked = insert(:user)

	{:ok, _user_relationship} = User.block(user, blocked)
	{:ok, _user_relationship} = User.block(reverse_blocked, user)

	{:ok, user, followed_zero} = User.follow(user, followed_zero)

	{:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])

	assert User.following?(user, followed_one)
	assert User.following?(user, followed_two)
	assert User.following?(user, followed_zero)
	refute User.following?(user, not_followed)
	refute User.following?(user, blocked)
	refute User.following?(user, reverse_blocked)
	end

	test "follow_all follows mutliple users without duplicating" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)

	{:ok, user} = User.follow_all(user, [followed_zero, followed_one])
	assert length(User.following(user)) == 3

	{:ok, user} = User.follow_all(user, [followed_one, followed_two])
	assert length(User.following(user)) == 4
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed} = User.follow(user, followed)

	user = User.get_cached_by_id(user.id)
	followed = User.get_cached_by_ap_id(followed.ap_id)

	assert followed.follower_count == 1
	assert user.following_count == 1

	assert User.ap_followers(followed) in User.following(user)
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, %{is_active: false})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	test "can't subscribe to a user who blocked us" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blocked)

	{:error, _} = User.subscribe(blocked, blocker)
	end

	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, is_locked: true)
	followed = insert(:user, is_locked: true)

	{:ok, follower, followed} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	describe "unfollow/2" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "unfollow with syncronizes external user" do
	clear_config([:instance, :external_user_synchronization], true)

	followed =
	insert(:user,
	nickname: "fuser1",
	follower_address: "http://localhost:4001/users/fuser1/followers",
	following_address: "http://localhost:4001/users/fuser1/following",
	ap_id: "http://localhost:4001/users/fuser1"
	)

	user =
	insert(:user, %{
	local: false,
	nickname: "fuser2",
	ap_id: "http://localhost:4001/users/fuser2",
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	})

	{:ok, user, followed} = User.follow(user, followed, :follow_accept)

	{:ok, user, _activity} = User.unfollow(user, followed)

	user = User.get_cached_by_id(user.id)

	assert User.following(user) == []
	end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user)

	{:ok, user, followed} = User.follow(user, followed, :follow_accept)

	assert User.following(user) == [user.follower_address, followed.follower_address]

	{:ok, user, _activity} = User.unfollow(user, followed)

	assert User.following(user) == [user.follower_address]
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	assert User.following(user) == [user.follower_address]
	end
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user)
	User.follow(user, followed, :follow_accept)

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	test "fetches correct profile for nickname beginning with number" do
	# Use old-style integer ID to try to reproduce the problem
	user = insert(:user, %{id: 1080})
	user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
	assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do: clear_config([:instance, :autofollowed_nicknames])
	setup do: clear_config([:instance, :autofollowing_nicknames])
	setup do: clear_config([:welcome])
	setup do: clear_config([:instance, :account_activation_required])

	test "it autofollows accounts that are set for it" do
	user = insert(:user)
	remote_user = insert(:user, %{local: false})

	clear_config([:instance, :autofollowed_nicknames], [
	user.nickname,
	remote_user.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(registered_user, user)
	refute User.following?(registered_user, remote_user)
	end

	test "it adds automatic followers for new registered accounts" do
	user1 = insert(:user)
	user2 = insert(:user)

	clear_config([:instance, :autofollowing_nicknames], [
	user1.nickname,
	user2.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(user1, registered_user)
	assert User.following?(user2, registered_user)
	end

	test "it sends a welcome message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :direct_message, :enabled], true)
	clear_config([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :direct_message, :message], "Hello, this is a direct message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "direct message"
	assert activity.actor == welcome_user.ap_id
	end

	test "it sends a welcome chat message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :chat_message, :enabled], true)
	clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "chat message"
	assert activity.actor == welcome_user.ap_id
	end

	setup do:
	clear_config(:mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	followers_only: [],
	accept: [],
	avatar_removal: [],
	banner_removal: [],
	reject_deletes: []
	)

	setup do:
	clear_config(:mrf,
	policies: [
	Pleroma.Web.ActivityPub.MRF.SimplePolicy
	]
	)

	test "it sends a welcome chat message when Simple policy applied to local instance" do
	clear_config([:mrf_simple, :media_nsfw], ["localhost"])

	welcome_user = insert(:user)
	clear_config([:welcome, :chat_message, :enabled], true)
	clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "chat message"
	assert activity.actor == welcome_user.ap_id
	end

	test "it sends a welcome email message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :email, :enabled], true)
	clear_config([:welcome, :email, :sender], welcome_user.email)

	clear_config(
	[:welcome, :email, :subject],
	"Hello, welcome to cool site: <%= instance_name %>"
	)

	instance_name = Pleroma.Config.get([:instance, :name])

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	assert_email_sent(
	from: {instance_name, welcome_user.email},
	to: {registered_user.name, registered_user.email},
	subject: "Hello, welcome to cool site: #{instance_name}",
	html_body: "Welcome to #{instance_name}"
	)
	end

	test "it sends a confirm email" do
	clear_config([:instance, :account_activation_required], true)

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	Pleroma.Emails.UserEmail.account_confirmation_email(registered_user)
	# temporary hackney fix until hackney max_connections bug is fixed
	# https://git.pleroma.social/pleroma/pleroma/-/issues/2101
	\|> Swoosh.Email.put_private(:hackney_options, ssl_options: [versions: [:"tlsv1.2"]])
	\|> assert_email_sent()
	end

	test "sends a pending approval email" do
	clear_config([:instance, :account_approval_required], true)

	{:ok, user} =
	User.register_changeset(%User{}, @full_user_data)
	\|> User.register()

	ObanHelpers.perform_all()

	assert_email_sent(
	from: Pleroma.Config.Helpers.sender(),
	to: {user.name, user.email},
	subject: "Your account is awaiting approval"
	)
	end

	test "it sends a registration confirmed email if no others will be sent" do
	clear_config([:welcome, :email, :enabled], false)
	clear_config([:instance, :account_activation_required], false)
	clear_config([:instance, :account_approval_required], false)

	{:ok, user} =
	User.register_changeset(%User{}, @full_user_data)
	\|> User.register()

	ObanHelpers.perform_all()

	instance_name = Pleroma.Config.get([:instance, :name])
	sender = Pleroma.Config.get([:instance, :notify_email])

	assert_email_sent(
	from: {instance_name, sender},
	to: {user.name, user.email},
	subject: "Account registered on #{instance_name}"
	)
	end

	test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
	clear_config([:instance, :account_activation_required], true)

	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do
	clear_config([:instance, :account_activation_required], false)

	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key in [:bio, :email], do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it restricts certain nicknames" do
	[restricted_name \| _] = Pleroma.Config.get([User, :restricted_nicknames])

	assert is_bitstring(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_name)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end

	test "it blocks blacklisted email domains" do
	clear_config([User, :email_blacklist], ["trolling.world"])

	# Block with match
	params = Map.put(@full_user_data, :email, "troll@trolling.world")
	changeset = User.register_changeset(%User{}, params)
	refute changeset.valid?

	# Block with subdomain match
	params = Map.put(@full_user_data, :email, "troll@gnomes.trolling.world")
	changeset = User.register_changeset(%User{}, params)
	refute changeset.valid?

	# Pass with different domains that are similar
	params = Map.put(@full_user_data, :email, "troll@gnomestrolling.world")
	changeset = User.register_changeset(%User{}, params)
	assert changeset.valid?

	params = Map.put(@full_user_data, :email, "troll@trolling.world.us")
	changeset = User.register_changeset(%User{}, params)
	assert changeset.valid?
	end

	test "it sets the password_hash and ap_id" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})

	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end

	test "it sets the 'accepts_chat_messages' set to true" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.accepts_chat_messages
	end

	test "it creates a confirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.is_confirmed
	end
	end

	describe "user registration, with :account_activation_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}
	setup do: clear_config([:instance, :account_activation_required], true)

	test "it creates unconfirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.is_confirmed
	assert user.confirmation_token
	end

	test "it creates confirmed user if :confirmed option is given" do
	changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.is_confirmed
	refute user.confirmation_token
	end
	end

	describe "user registration, with :account_approval_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com",
	registration_reason: "I'm a cool guy :)"
	}
	setup do: clear_config([:instance, :account_approval_required], true)

	test "it creates unapproved user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.is_approved
	assert user.registration_reason == "I'm a cool guy :)"
	end

	test "it restricts length of registration reason" do
	reason_limit = Pleroma.Config.get([:instance, :registration_reason_length])

	assert is_integer(reason_limit)

	params =
	@full_user_data
	\|> Map.put(
	:registration_reason,
	"Quia et nesciunt dolores numquam ipsam nisi sapiente soluta. Ullam repudiandae nisi quam porro officiis officiis ad. Consequatur animi velit ex quia. Odit voluptatem perferendis quia ut nisi. Dignissimos sit soluta atque aliquid dolorem ut dolorum ut. Labore voluptates iste iusto amet voluptatum earum. Ad fugit illum nam eos ut nemo. Pariatur ea fuga non aspernatur. Dignissimos debitis officia corporis est nisi ab et. Atque itaque alias eius voluptas minus. Accusamus numquam tempore occaecati in."
	)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end
	end

	describe "get_or_fetch/1" do
	test "gets an existing user by nickname" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user by ap_id" do
	ap_id = "http://mastodon.example.org/users/admin"

	user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: ap_id
	)

	{:ok, fetched_user} = User.get_or_fetch(ap_id)
	freshed_user = refresh_record(user)
	assert freshed_user == fetched_user
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	{:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname" do
	user = insert(:user)

	{:ok, fetched_user} =
	User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname, case insensitive" do
	user = insert(:user, nickname: "nick")
	casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	{:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)

	assert user == fetched_user
	end

	@tag capture_log: true
	test "returns nil if no user could be fetched" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == "not found nonexistant@social.heldscal.la"
	end

	test "returns nil for nonexistant local user" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == "not found nonexistant"
	end

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")

	assert user.inbox

	refute user.last_refreshed_at == orig_user.last_refreshed_at
	end

	test "if nicknames clash, the old user gets a prefix with the old id to the nickname" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")

	assert user.inbox

	refute user.id == orig_user.id

	orig_user = User.get_by_id(orig_user.id)

	assert orig_user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
	end

	@tag capture_log: true
	test "it returns the old user if stale, but unfetchable" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/raymoo",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/raymoo")

	assert user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.user_feed_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.user_feed_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	avatar: %{some: "avatar"}
	}
	setup do: clear_config([:instance, :user_bio_length])
	setup do: clear_config([:instance, :user_name_length])

	test "it confirms validity" do
	cs = User.remote_user_changeset(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_changeset(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_changeset(%{@valid_remote \| nickname: "bla"})
	assert Ecto.Changeset.get_field(cs, :local) == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_changeset(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it is invalid given a local user" do
	user = insert(:user)
	cs = User.remote_user_changeset(user, %{name: "tom from myspace"})

	refute cs.valid?
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one, user} = User.follow(follower_one, user)
	{:ok, follower_two, user} = User.follow(follower_two, user)

	res = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user, followed_one} = User.follow(user, followed_one)
	{:ok, user, followed_two} = User.follow(user, followed_two)

	res = User.get_friends(user)

	followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
	followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the note_count property" do
	note = insert(:note)

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

	assert user.note_count == 0

	{:ok, user} = User.update_note_count(user)

	assert user.note_count == 1
	end

	test "it increases the note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 2
	end

	test "it decreases the note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 1

	{:ok, user} = User.decrease_note_count(user)

	assert user.note_count == 0

	{:ok, user} = User.decrease_note_count(user)

	assert user.note_count == 0
	end

	test "it sets the follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.follower_count == 0

	{:ok, user} = User.update_follower_count(user)

	assert user.follower_count == 1
	end
	end

	describe "mutes" do
	test "it mutes people" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

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

	assert User.mutes?(user, muted_user)
	assert User.muted_notifications?(user, muted_user)
	end

	test "expiring" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user, %{expires_in: 60})
	assert User.mutes?(user, muted_user)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unmute_user", "muter_id" => user.id, "mutee_id" => muted_user.id}

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it unmutes users" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user)
	{:ok, _user_mute} = User.unmute(user, muted_user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it unmutes users by id" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user)
	{:ok, _user_mute} = User.unmute(user.id, muted_user.id)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it mutes user without notifications" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

	{:ok, _user_relationships} = User.mute(user, muted_user, %{notifications: false})

	assert User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

	{:ok, _user_relationship} = User.block(user, blocked_user)

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, _user_relationship} = User.block(user, blocked_user)
	{:ok, _user_block} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker, blocked} = User.follow(blocker, blocked)
	{:ok, blocked, blocker} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker, blocked} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked, blocker} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker subscription relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, _subscription} = User.subscribe(blocked, blocker)

	assert User.subscribed_to?(blocked, blocker)
	refute User.subscribed_to?(blocker, blocked)

	{:ok, _user_relationship} = User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	refute User.subscribed_to?(blocker, blocked)
	refute User.subscribed_to?(blocked, blocker)
	end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end if wildcard added" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "blocks domain with wildcard for subdomain" do
	user = insert(:user)

	user_from_subdomain =
	insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})

	user_with_two_subdomains =
	insert(:user, %{
	ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
	})

	user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	assert User.blocks?(user, user_from_subdomain)
	assert User.blocks?(user, user_with_two_subdomains)
	assert User.blocks?(user, user_domain)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "follows take precedence over domain blocks" do
	user = insert(:user)
	good_eggo = insert(:user, %{ap_id: "https://meanies.social/user/cuteposter"})

	{:ok, user} = User.block_domain(user, "meanies.social")
	{:ok, user, good_eggo} = User.follow(user, good_eggo)

	refute User.blocks?(user, good_eggo)
	end
	end

	describe "get_recipients_from_activity" do
	test "works for announces" do
	actor = insert(:user)
	user = insert(:user, local: true)

	{:ok, activity} = CommonAPI.post(actor, %{status: "hello"})
	{:ok, announce} = CommonAPI.repeat(activity.id, user)

	recipients = User.get_recipients_from_activity(announce)

	assert user in recipients
	end

	test "get recipients" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	status: "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, user, actor} = User.follow(user, actor)
	{:ok, _user_two, _actor} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 3
	assert user in recipients
	assert addressed in recipients
	end

	test "has following" do
	actor = insert(:user)
	user = insert(:user)
	user_two = insert(:user)
	addressed = insert(:user, local: true)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	status: "hey @#{addressed.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, _actor, _user} = User.follow(actor, user)
	{:ok, _actor, _user_two} = User.follow(actor, user_two)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 2
	assert addressed in recipients
	end
	end

	describe ".set_activation" do
	test "can de-activate then re-activate a user" do
	user = insert(:user)
	assert user.is_active
	{:ok, user} = User.set_activation(user, false)
	refute user.is_active
	{:ok, user} = User.set_activation(user, true)
	assert user.is_active
	end

	test "hide a user from followers" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user, user2} = User.follow(user, user2)
	{:ok, _user} = User.set_activation(user, false)

	user2 = User.get_cached_by_id(user2.id)

	assert user2.follower_count == 0
	assert [] = User.get_followers(user2)
	end

	test "hide a user from friends" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2, user} = User.follow(user2, user)
	assert user2.following_count == 1
	assert User.following_count(user2) == 1

	{:ok, _user} = User.set_activation(user, false)

	user2 = User.get_cached_by_id(user2.id)

	assert refresh_record(user2).following_count == 0
	assert user2.following_count == 0
	assert User.following_count(user2) == 0
	assert [] = User.get_friends(user2)
	end

	test "hide a user's statuses from timelines and notifications" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2, user} = User.follow(user2, user)

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

	activity = Repo.preload(activity, :bookmark)

	[notification] = Pleroma.Notification.for_user(user2)
	assert notification.activity.id == activity.id

	assert [activity] == ActivityPub.fetch_public_activities(%{}) \|> Repo.preload(:bookmark)

	assert [%{activity \| thread_muted?: CommonAPI.thread_muted?(user2, activity)}] ==
	ActivityPub.fetch_activities([user2.ap_id \| User.following(user2)], %{
	user: user2
	})

	{:ok, _user} = User.set_activation(user, false)

	assert [] == ActivityPub.fetch_public_activities(%{})
	assert [] == Pleroma.Notification.for_user(user2)

	assert [] ==
	ActivityPub.fetch_activities([user2.ap_id \| User.following(user2)], %{
	user: user2
	})
	end
	end

	describe "approve" do
	test "approves a user" do
	user = insert(:user, is_approved: false)
	refute user.is_approved
	{:ok, user} = User.approve(user)
	assert user.is_approved
	end

	test "approves a list of users" do
	unapproved_users = [
	insert(:user, is_approved: false),
	insert(:user, is_approved: false),
	insert(:user, is_approved: false)
	]

	{:ok, users} = User.approve(unapproved_users)

	assert Enum.count(users) == 3

	Enum.each(users, fn user ->
	assert user.is_approved
	end)
	end

	test "it sends welcome email if it is set" do
	clear_config([:welcome, :email, :enabled], true)
	clear_config([:welcome, :email, :sender], "tester@test.me")

	user = insert(:user, is_approved: false)
	welcome_user = insert(:user, email: "tester@test.me")
	instance_name = Pleroma.Config.get([:instance, :name])

	User.approve(user)

	ObanHelpers.perform_all()

	assert_email_sent(
	from: {instance_name, welcome_user.email},
	to: {user.name, user.email},
	html_body: "Welcome to #{instance_name}"
	)
	end

	test "approving an approved user does not trigger post-register actions" do
	clear_config([:welcome, :email, :enabled], true)

	user = insert(:user, is_approved: true)
	User.approve(user)

	ObanHelpers.perform_all()

	assert_no_email_sent()
	end
	end

	describe "confirm" do
	test "confirms a user" do
	user = insert(:user, is_confirmed: false)
	refute user.is_confirmed
	{:ok, user} = User.confirm(user)
	assert user.is_confirmed
	end

	test "confirms a list of users" do
	unconfirmed_users = [
	insert(:user, is_confirmed: false),
	insert(:user, is_confirmed: false),
	insert(:user, is_confirmed: false)
	]

	{:ok, users} = User.confirm(unconfirmed_users)

	assert Enum.count(users) == 3

	Enum.each(users, fn user ->
	assert user.is_confirmed
	end)
	end

	test "sends approval emails when `is_approved: false`" do
	admin = insert(:user, is_admin: true)
	user = insert(:user, is_confirmed: false, is_approved: false)
	User.confirm(user)

	ObanHelpers.perform_all()

	user_email = Pleroma.Emails.UserEmail.approval_pending_email(user)
	admin_email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, user)

	notify_email = Pleroma.Config.get([:instance, :notify_email])
	instance_name = Pleroma.Config.get([:instance, :name])

	# User approval email
	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: user_email.html_body
	)

	# Admin email
	assert_email_sent(
	from: {instance_name, notify_email},
	to: {admin.name, admin.email},
	html_body: admin_email.html_body
	)
	end

	test "confirming a confirmed user does not trigger post-register actions" do
	user = insert(:user, is_confirmed: true, is_approved: false)
	User.confirm(user)

	ObanHelpers.perform_all()

	assert_no_email_sent()
	end
	end

	describe "delete" do
	setup do
	{:ok, user} = insert(:user) \|> User.set_cache()

	[user: user]
	end

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

	test ".delete_user_activities deletes all create activities", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "2hu"})

	User.delete_user_activities(user)

	# TODO: Test removal favorites, repeats, delete activities.
	refute Activity.get_by_id(activity.id)
	end

	test "it deactivates a user, all follow relationships and all activities", %{user: user} do
	follower = insert(:user)
	{:ok, follower, user} = User.follow(follower, user)

	locked_user = insert(:user, name: "locked", is_locked: true)
	{:ok, _, _} = User.follow(user, locked_user, :follow_pending)

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

	object_two = insert(:note, user: follower)
	activity_two = insert(:note_activity, user: follower, note: object_two)

	{:ok, like} = CommonAPI.favorite(user, activity_two.id)
	{:ok, like_two} = CommonAPI.favorite(follower, activity.id)
	{:ok, repeat} = CommonAPI.repeat(activity_two.id, user)

	{:ok, job} = User.delete(user)
	{:ok, _user} = ObanHelpers.perform(job)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	assert %{is_active: false} = User.get_by_id(user.id)

	assert [] == User.get_follow_requests(locked_user)

	user_activities =
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.all()
	\|> Enum.map(fn act -> act.data["type"] end)

	assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)

	refute Activity.get_by_id(activity.id)
	refute Activity.get_by_id(like.id)
	refute Activity.get_by_id(like_two.id)
	refute Activity.get_by_id(repeat.id)
	end
	end

	test "delete/1 when confirmation is pending deletes the user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: false)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	refute User.get_cached_by_id(user.id)
	refute User.get_by_id(user.id)
	end

	test "delete/1 when approval is pending deletes the user" do
	user = insert(:user, is_approved: false)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	refute User.get_cached_by_id(user.id)
	refute User.get_by_id(user.id)
	end

	test "delete/1 purges a user when they wouldn't be fully deleted" do
	user =
	insert(:user, %{
	bio: "eyy lmao",
	name: "qqqqqqq",
	password_hash: "pdfk2$1b3n159001",
	keys: "RSA begin buplic key",
	public_key: "--PRIVATE KEYE--",
	avatar: %{"a" => "b"},
	tags: ["qqqqq"],
	banner: %{"a" => "b"},
	background: %{"a" => "b"},
	note_count: 9,
	follower_count: 9,
	following_count: 9001,
	is_locked: true,
	is_confirmed: false,
	password_reset_pending: true,
	is_approved: false,
	registration_reason: "ahhhhh",
	confirmation_token: "qqqq",
	domain_blocks: ["lain.com"],
	is_active: false,
	ap_enabled: true,
	is_moderator: true,
	is_admin: true,
	mastofe_settings: %{"a" => "b"},
	mascot: %{"a" => "b"},
	emoji: %{"a" => "b"},
	pleroma_settings_store: %{"q" => "x"},
	fields: [%{"gg" => "qq"}],
	raw_fields: [%{"gg" => "qq"}],
	is_discoverable: true,
	also_known_as: ["https://lol.olo/users/loll"]
	})

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)
	user = User.get_by_id(user.id)

	assert %User{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	keys: nil,
	public_key: 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,
	is_confirmed: true,
	password_reset_pending: false,
	is_approved: true,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	is_active: false,
	ap_enabled: false,
	is_moderator: false,
	is_admin: false,
	mastofe_settings: nil,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	} = user
	end

	test "get_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns default policies, when rich-text is enabled" do
	user = insert(:user)

	assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, no_rich_text: true)

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)

	User.set_cache(user)
	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	describe "account_status/1" do
	setup do: clear_config([:instance, :account_activation_required])

	test "return confirmation_pending for unconfirm user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: false)
	assert User.account_status(user) == :confirmation_pending
	end

	test "return active for confirmed user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: true)
	assert User.account_status(user) == :active
	end

	test "return active for remote user" do
	user = insert(:user, local: false)
	assert User.account_status(user) == :active
	end

	test "returns :password_reset_pending for user with reset password" do
	user = insert(:user, password_reset_pending: true)
	assert User.account_status(user) == :password_reset_pending
	end

	test "returns :deactivated for deactivated user" do
	user = insert(:user, local: true, is_confirmed: true, is_active: false)
	assert User.account_status(user) == :deactivated
	end

	test "returns :approval_pending for unapproved user" do
	user = insert(:user, local: true, is_approved: false)
	assert User.account_status(user) == :approval_pending

	user = insert(:user, local: true, is_confirmed: false, is_approved: false)
	assert User.account_status(user) == :approval_pending
	end
	end

	describe "superuser?/1" do
	test "returns false for unprivileged users" do
	user = insert(:user, local: true)

	refute User.superuser?(user)
	end

	test "returns false for remote users" do
	user = insert(:user, local: false)
	remote_admin_user = insert(:user, local: false, is_admin: true)

	refute User.superuser?(user)
	refute User.superuser?(remote_admin_user)
	end

	test "returns true for local moderators" do
	user = insert(:user, local: true, is_moderator: true)

	assert User.superuser?(user)
	end

	test "returns true for local admins" do
	user = insert(:user, local: true, is_admin: true)

	assert User.superuser?(user)
	end
	end

	describe "invisible?/1" do
	test "returns true for an invisible user" do
	user = insert(:user, local: true, invisible: true)

	assert User.invisible?(user)
	end

	test "returns false for a non-invisible user" do
	user = insert(:user, local: true)

	refute User.invisible?(user)
	end
	end

	describe "visible_for/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for(user, user) == :visible
	end

	test "returns false when the account is unconfirmed and confirmation is required" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: true, is_confirmed: false)
	other_user = insert(:user, local: true)

	refute User.visible_for(user, other_user) == :visible
	end

	test "returns true when the account is unconfirmed and confirmation is required but the account is remote" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: false, is_confirmed: false)
	other_user = insert(:user, local: true)

	assert User.visible_for(user, other_user) == :visible
	end

	test "returns true when the account is unconfirmed and being viewed by a privileged account (confirmation required)" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: true, is_confirmed: false)
	other_user = insert(:user, local: true, is_admin: true)

	assert User.visible_for(user, other_user) == :visible
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	~s(A.k.a. <span class="h-card"><a class="u-url mention" data-user="#{remote_user.id}" href="#{
	remote_user.ap_id
	}" rel="ugc">@<span>nick@domain.com</span></a></span>)

	assert expected_text == User.parse_bio(bio, user)
	end

	test "Adds rel=me on linkbacked urls" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	bio = "http://example.com/rel_me/null"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/link"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/anchor"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "follower count is updated when a follower is blocked" do
	user = insert(:user)
	follower = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)

	{:ok, follower, user} = User.follow(follower, user)
	{:ok, _follower2, _user} = User.follow(follower2, user)
	{:ok, _follower3, _user} = User.follow(follower3, user)

	{:ok, _user_relationship} = User.block(user, follower)
	user = refresh_record(user)

	assert user.follower_count == 2
	end

	describe "list_inactive_users_query/1" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Users are inactive by default" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(users, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users who has no recent activity" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	{inactive, active} = Enum.split(users, trunc(total / 2))

	Enum.map(active, fn user ->
	to = Enum.random(users -- [user])

	{:ok, _} =
	CommonAPI.post(user, %{
	status: "hey @#{to.nickname}"
	})
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users with no read notifications" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	[sender \| recipients] = users
	{inactive, active} = Enum.split(recipients, trunc(total / 2))

	Enum.each(recipients, fn to ->
	{:ok, _} =
	CommonAPI.post(sender, %{
	status: "hey @#{to.nickname}"
	})

	{:ok, _} =
	CommonAPI.post(sender, %{
	status: "hey again @#{to.nickname}"
	})
	end)

	Enum.each(active, fn user ->
	[n1, _n2] = Pleroma.Notification.for_user(user)
	{:ok, _} = Pleroma.Notification.read_one(user, n1.id)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end
	end

	describe "ensure_keys_present" do
	test "it creates keys for a user and stores them in info" do
	user = insert(:user)
	refute is_binary(user.keys)
	{:ok, user} = User.ensure_keys_present(user)
	assert is_binary(user.keys)
	end

	test "it doesn't create keys if there already are some" do
	user = insert(:user, keys: "xxx")
	{:ok, user} = User.ensure_keys_present(user)
	assert user.keys == "xxx"
	end
	end

	describe "get_ap_ids_by_nicknames" do
	test "it returns a list of AP ids for a given set of nicknames" do
	user = insert(:user)
	user_two = insert(:user)

	ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
	assert length(ap_ids) == 2
	assert user.ap_id in ap_ids
	assert user_two.ap_id in ap_ids
	end
	end

	describe "sync followers count" do
	setup do
	user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
	user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
	insert(:user, local: true)
	insert(:user, local: false, is_active: false)
	{:ok, user1: user1, user2: user2}
	end

	test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
	[fdb_user1] = User.external_users(limit: 1)

	assert fdb_user1.ap_id
	assert fdb_user1.ap_id == user1.ap_id
	assert fdb_user1.id == user1.id

	[fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)

	assert fdb_user2.ap_id
	assert fdb_user2.ap_id == user2.ap_id
	assert fdb_user2.id == user2.id

	assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
	end
	end

	describe "is_internal_user?/1" do
	test "non-internal user returns false" do
	user = insert(:user)
	refute User.is_internal_user?(user)
	end

	test "user with no nickname returns true" do
	user = insert(:user, %{nickname: nil})
	assert User.is_internal_user?(user)
	end

	test "user with internal-prefixed nickname returns true" do
	user = insert(:user, %{nickname: "internal.test"})
	assert User.is_internal_user?(user)
	end
	end

	describe "update_and_set_cache/1" do
	test "returns error when user is stale instead Ecto.StaleEntryError" do
	user = insert(:user)

	changeset = Ecto.Changeset.change(user, bio: "test")

	Repo.delete(user)

	assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
	User.update_and_set_cache(changeset)
	end

	test "performs update cache if user updated" do
	user = insert(:user)
	assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	changeset = Ecto.Changeset.change(user, bio: "test-bio")

	assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
	assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
	end
	end

	describe "following/followers synchronization" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "updates the counters normally on following/getting a follow when disabled" do
	clear_config([:instance, :external_user_synchronization], false)
	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	ap_enabled: true
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	{:ok, user, other_user} = Pleroma.User.follow(user, other_user)

	assert user.following_count == 1
	assert other_user.follower_count == 1
	end

	test "syncronizes the counters with the remote instance for the followed when enabled" do
	clear_config([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	ap_enabled: true
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	clear_config([:instance, :external_user_synchronization], true)
	{:ok, _user, other_user} = User.follow(user, other_user)

	assert other_user.follower_count == 437
	end

	test "syncronizes the counters with the remote instance for the follower when enabled" do
	clear_config([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	ap_enabled: true
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	clear_config([:instance, :external_user_synchronization], true)
	{:ok, other_user, _user} = User.follow(other_user, user)

	assert other_user.following_count == 152
	end
	end

	describe "change_email/2" do
	setup do
	[user: insert(:user)]
	end

	test "blank email returns error", %{user: user} do
	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
	end

	test "non unique email returns error", %{user: user} do
	%{email: email} = insert(:user)

	assert {:error, %{errors: [email: {"has already been taken", _}]}} =
	User.change_email(user, email)
	end

	test "invalid email returns error", %{user: user} do
	assert {:error, %{errors: [email: {"has invalid format", _}]}} =
	User.change_email(user, "cofe")
	end

	test "changes email", %{user: user} do
	assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
	end
	end

	describe "get_cached_by_nickname_or_id" do
	setup do
	local_user = insert(:user)
	remote_user = insert(:user, nickname: "nickname@example.com", local: false)

	[local_user: local_user, remote_user: remote_user]
	end

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

	test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
	remote_user: remote_user
	} do
	clear_config([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	clear_config([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
	end

	test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user} do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user, local_user: local_user} do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
	end

	test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
	%{remote_user: remote_user} do
	clear_config([:instance, :limit_to_local_content], true)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
	%{local_user: local_user} do
	clear_config([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	clear_config([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
	end
	end

	describe "update_email_notifications/2" do
	setup do
	user = insert(:user, email_notifications: %{"digest" => true})

	{:ok, user: user}
	end

	test "Notifications are updated", %{user: user} do
	true = user.email_notifications["digest"]
	assert {:ok, result} = User.update_email_notifications(user, %{"digest" => false})
	assert result.email_notifications["digest"] == false
	end
	end

	describe "local_nickname/1" do
	test "returns nickname without host" do
	assert User.local_nickname("@mentioned") == "mentioned"
	assert User.local_nickname("a_local_nickname") == "a_local_nickname"
	assert User.local_nickname("nickname@host.com") == "nickname"
	end
	end

	describe "full_nickname/1" do
	test "returns fully qualified nickname for local and remote users" do
	local_user =
	insert(:user, nickname: "local_user", ap_id: "https://somehost.com/users/local_user")

	remote_user = insert(:user, nickname: "remote@host.com", local: false)

	assert User.full_nickname(local_user) == "local_user@somehost.com"
	assert User.full_nickname(remote_user) == "remote@host.com"
	end

	test "strips leading @ from mentions" do
	assert User.full_nickname("@mentioned") == "mentioned"
	assert User.full_nickname("@nickname@host.com") == "nickname@host.com"
	end

	test "does not modify nicknames" do
	assert User.full_nickname("nickname") == "nickname"
	assert User.full_nickname("nickname@host.com") == "nickname@host.com"
	end
	end

	test "avatar fallback" do
	user = insert(:user)
	assert User.avatar_url(user) =~ "/images/avi.png"

	clear_config([:assets, :default_user_avatar], "avatar.png")

	user = User.get_cached_by_nickname_or_id(user.nickname)
	assert User.avatar_url(user) =~ "avatar.png"

	assert User.avatar_url(user, no_default: true) == nil
	end

	test "get_host/1" do
	user = insert(:user, ap_id: "https://lain.com/users/lain", nickname: "lain")
	assert User.get_host(user) == "lain.com"
	end

	test "update_last_active_at/1" do
	user = insert(:user)
	assert is_nil(user.last_active_at)

	test_started_at = NaiveDateTime.utc_now() \|> NaiveDateTime.truncate(:second)

	assert {:ok, user} = User.update_last_active_at(user)

	assert user.last_active_at >= test_started_at
	assert user.last_active_at <= NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	last_active_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(-:timer.hours(24), :millisecond)
	\|> NaiveDateTime.truncate(:second)

	assert {:ok, user} =
	user
	\|> cast(%{last_active_at: last_active_at}, [:last_active_at])
	\|> User.update_and_set_cache()

	assert user.last_active_at == last_active_at
	assert {:ok, user} = User.update_last_active_at(user)
	assert user.last_active_at >= test_started_at
	assert user.last_active_at <= NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	end

	test "active_user_count/1" do
	insert(:user)
	insert(:user, %{local: false})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -5)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -3)})
	insert(:user, %{last_active_at: NaiveDateTime.utc_now()})

	assert User.active_user_count() == 2
	assert User.active_user_count(6) == 3
	assert User.active_user_count(1) == 1
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/simple_policy_test.exs b/test/pleroma/web/activity_pub/mrf/simple_policy_test.exs
	index f48e5b39b..ebd38caca 100644
	--- a/test/pleroma/web/activity_pub/mrf/simple_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/simple_policy_test.exs
	@@ -1,538 +1,538 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Web.ActivityPub.MRF.SimplePolicy
	alias Pleroma.Web.CommonAPI

	setup do:
	clear_config(:mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	followers_only: [],
	accept: [],
	avatar_removal: [],
	banner_removal: [],
	reject_deletes: []
	)

	describe "when :media_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :media_removal], [])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) == {:ok, media_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :media_removal], ["remote.instance"])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> Map.put("object", Map.delete(media_message["object"], "attachment"))}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :media_removal], ["*.remote.instance"])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> Map.put("object", Map.delete(media_message["object"], "attachment"))}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end
	end

	describe "when :media_nsfw" do
	test "is empty" do
	clear_config([:mrf_simple, :media_nsfw], [])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) == {:ok, media_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :media_nsfw], ["remote.instance"])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> put_in(["object", "tag"], ["foo", "nsfw"])
	\|> put_in(["object", "sensitive"], true)}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :media_nsfw], ["*.remote.instance"])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> put_in(["object", "tag"], ["foo", "nsfw"])
	\|> put_in(["object", "sensitive"], true)}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end
	end

	defp build_media_message do
	%{
	"actor" => "https://remote.instance/users/bob",
	"type" => "Create",
	"object" => %{
	"attachment" => [%{}],
	"tag" => ["foo"],
	"sensitive" => false
	}
	}
	end

	describe "when :report_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :report_removal], [])
	report_message = build_report_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(report_message) == {:ok, report_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :report_removal], ["remote.instance"])
	report_message = build_report_message()
	local_message = build_local_message()

	assert {:reject, _} = SimplePolicy.filter(report_message)
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :report_removal], ["*.remote.instance"])
	report_message = build_report_message()
	local_message = build_local_message()

	assert {:reject, _} = SimplePolicy.filter(report_message)
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end
	end

	defp build_report_message do
	%{
	"actor" => "https://remote.instance/users/bob",
	"type" => "Flag"
	}
	end

	describe "when :federated_timeline_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :federated_timeline_removal], [])
	{_, ftl_message} = build_ftl_actor_and_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	{actor, ftl_message} = build_ftl_actor_and_message()

	ftl_message_actor_host =
	ftl_message
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	clear_config([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
	local_message = build_local_message()

	assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
	assert actor.follower_address in ftl_message["to"]
	refute actor.follower_address in ftl_message["cc"]
	refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "match with wildcard domain" do
	{actor, ftl_message} = build_ftl_actor_and_message()

	ftl_message_actor_host =
	ftl_message
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	clear_config([:mrf_simple, :federated_timeline_removal], ["*." <> ftl_message_actor_host])
	local_message = build_local_message()

	assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
	assert actor.follower_address in ftl_message["to"]
	refute actor.follower_address in ftl_message["cc"]
	refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host but only as:Public in to" do
	{_actor, ftl_message} = build_ftl_actor_and_message()

	ftl_message_actor_host =
	ftl_message
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	ftl_message = Map.put(ftl_message, "cc", [])

	clear_config([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])

	assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
	refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
	end
	end

	defp build_ftl_actor_and_message do
	actor = insert(:user)

	{actor,
	%{
	"actor" => actor.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
	"cc" => [actor.follower_address, "http://foo.bar/qux"]
	}}
	end

	describe "when :reject" do
	test "is empty" do
	clear_config([:mrf_simple, :reject], [])

	remote_message = build_remote_message()

	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	end

	test "activity has a matching host" do
	clear_config([:mrf_simple, :reject], ["remote.instance"])

	remote_message = build_remote_message()

	assert {:reject, _} = SimplePolicy.filter(remote_message)
	end

	test "activity matches with wildcard domain" do
	clear_config([:mrf_simple, :reject], ["*.remote.instance"])

	remote_message = build_remote_message()

	assert {:reject, _} = SimplePolicy.filter(remote_message)
	end

	test "actor has a matching host" do
	clear_config([:mrf_simple, :reject], ["remote.instance"])

	remote_user = build_remote_user()

	assert {:reject, _} = SimplePolicy.filter(remote_user)
	end
	end

	describe "when :followers_only" do
	test "is empty" do
	clear_config([:mrf_simple, :followers_only], [])
	{_, ftl_message} = build_ftl_actor_and_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	actor = insert(:user)
	following_user = insert(:user)
	non_following_user = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(following_user, actor)

	activity = %{
	"actor" => actor.ap_id,
	"to" => [
	"https://www.w3.org/ns/activitystreams#Public",
	following_user.ap_id,
	non_following_user.ap_id
	],
	"cc" => [actor.follower_address, "http://foo.bar/qux"]
	}

	dm_activity = %{
	"actor" => actor.ap_id,
	"to" => [
	following_user.ap_id,
	non_following_user.ap_id
	],
	"cc" => []
	}

	actor_domain =
	activity
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	clear_config([:mrf_simple, :followers_only], [actor_domain])

	assert {:ok, new_activity} = SimplePolicy.filter(activity)
	assert actor.follower_address in new_activity["cc"]
	assert following_user.ap_id in new_activity["to"]
	refute "https://www.w3.org/ns/activitystreams#Public" in new_activity["to"]
	refute "https://www.w3.org/ns/activitystreams#Public" in new_activity["cc"]
	refute non_following_user.ap_id in new_activity["to"]
	refute non_following_user.ap_id in new_activity["cc"]

	assert {:ok, new_dm_activity} = SimplePolicy.filter(dm_activity)
	assert new_dm_activity["to"] == [following_user.ap_id]
	assert new_dm_activity["cc"] == []
	end
	end

	describe "when :accept" do
	test "is empty" do
	clear_config([:mrf_simple, :accept], [])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	end

	test "is not empty but activity doesn't have a matching host" do
	clear_config([:mrf_simple, :accept], ["non.matching.remote"])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert {:reject, _} = SimplePolicy.filter(remote_message)
	end

	test "activity has a matching host" do
	clear_config([:mrf_simple, :accept], ["remote.instance"])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	end

	test "activity matches with wildcard domain" do
	clear_config([:mrf_simple, :accept], ["*.remote.instance"])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	end

	test "actor has a matching host" do
	clear_config([:mrf_simple, :accept], ["remote.instance"])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end
	end

	describe "when :avatar_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :avatar_removal], [])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end

	test "is not empty but it doesn't have a matching host" do
	clear_config([:mrf_simple, :avatar_removal], ["non.matching.remote"])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :avatar_removal], ["remote.instance"])

	remote_user = build_remote_user()
	{:ok, filtered} = SimplePolicy.filter(remote_user)

	refute filtered["icon"]
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :avatar_removal], ["*.remote.instance"])

	remote_user = build_remote_user()
	{:ok, filtered} = SimplePolicy.filter(remote_user)

	refute filtered["icon"]
	end
	end

	describe "when :banner_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :banner_removal], [])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end

	test "is not empty but it doesn't have a matching host" do
	clear_config([:mrf_simple, :banner_removal], ["non.matching.remote"])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :banner_removal], ["remote.instance"])

	remote_user = build_remote_user()
	{:ok, filtered} = SimplePolicy.filter(remote_user)

	refute filtered["image"]
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :banner_removal], ["*.remote.instance"])

	remote_user = build_remote_user()
	{:ok, filtered} = SimplePolicy.filter(remote_user)

	refute filtered["image"]
	end
	end

	describe "when :reject_deletes is empty" do
	setup do: clear_config([:mrf_simple, :reject_deletes], [])

	test "it accepts deletions even from rejected servers" do
	clear_config([:mrf_simple, :reject], ["remote.instance"])

	deletion_message = build_remote_deletion_message()

	assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
	end

	test "it accepts deletions even from non-whitelisted servers" do
	clear_config([:mrf_simple, :accept], ["non.matching.remote"])

	deletion_message = build_remote_deletion_message()

	assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
	end
	end

	describe "when :reject_deletes is not empty but it doesn't have a matching host" do
	setup do: clear_config([:mrf_simple, :reject_deletes], ["non.matching.remote"])

	test "it accepts deletions even from rejected servers" do
	clear_config([:mrf_simple, :reject], ["remote.instance"])

	deletion_message = build_remote_deletion_message()

	assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
	end

	test "it accepts deletions even from non-whitelisted servers" do
	clear_config([:mrf_simple, :accept], ["non.matching.remote"])

	deletion_message = build_remote_deletion_message()

	assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
	end
	end

	describe "when :reject_deletes has a matching host" do
	setup do: clear_config([:mrf_simple, :reject_deletes], ["remote.instance"])

	test "it rejects the deletion" do
	deletion_message = build_remote_deletion_message()

	assert {:reject, _} = SimplePolicy.filter(deletion_message)
	end
	end

	describe "when :reject_deletes match with wildcard domain" do
	setup do: clear_config([:mrf_simple, :reject_deletes], ["*.remote.instance"])

	test "it rejects the deletion" do
	deletion_message = build_remote_deletion_message()

	assert {:reject, _} = SimplePolicy.filter(deletion_message)
	end
	end

	defp build_local_message do
	%{
	- "actor" => "#{Pleroma.Web.base_url()}/users/alice",
	+ "actor" => "#{Pleroma.Web.Endpoint.url()}/users/alice",
	"to" => [],
	"cc" => []
	}
	end

	defp build_remote_message do
	%{"actor" => "https://remote.instance/users/bob"}
	end

	defp build_remote_user do
	%{
	"id" => "https://remote.instance/users/bob",
	"icon" => %{
	"url" => "http://example.com/image.jpg",
	"type" => "Image"
	},
	"image" => %{
	"url" => "http://example.com/image.jpg",
	"type" => "Image"
	},
	"type" => "Person"
	}
	end

	defp build_remote_deletion_message do
	%{
	"type" => "Delete",
	"actor" => "https://remote.instance/users/bob"
	}
	end
	end
	diff --git a/test/pleroma/web/activity_pub/publisher_test.exs b/test/pleroma/web/activity_pub/publisher_test.exs
	index f0ce3d7f2..89f3ad411 100644
	--- a/test/pleroma/web/activity_pub/publisher_test.exs
	+++ b/test/pleroma/web/activity_pub/publisher_test.exs
	@@ -1,364 +1,364 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.PublisherTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	alias Pleroma.Activity
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Publisher
	alias Pleroma.Web.CommonAPI

	@as_public "https://www.w3.org/ns/activitystreams#Public"

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

	setup_all do: clear_config([:instance, :federating], true)

	describe "gather_webfinger_links/1" do
	test "it returns links" do
	user = insert(:user)

	expected_links = [
	%{"href" => user.ap_id, "rel" => "self", "type" => "application/activity+json"},
	%{
	"href" => user.ap_id,
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	- "template" => "#{Pleroma.Web.base_url()}/ostatus_subscribe?acct={uri}"
	+ "template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
	}
	]

	assert expected_links == Publisher.gather_webfinger_links(user)
	end
	end

	describe "determine_inbox/2" do
	test "it returns sharedInbox for messages involving as:Public in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"to" => [@as_public], "cc" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving as:Public in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"cc" => [@as_public], "to" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"cc" => [], "to" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"to" => [], "cc" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	user_two = insert(:user)

	activity = %Activity{
	data: %{"to" => [user_two.ap_id], "cc" => [user.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns inbox for messages involving single recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	activity = %Activity{
	data: %{"to" => [user.ap_id], "cc" => []}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/personal-inbox"
	end
	end

	describe "publish_one/1" do
	test "publish to url with with different ports" do
	inbox80 = "http://42.site/users/nick1/inbox"
	inbox42 = "http://42.site:42/users/nick1/inbox"

	mock(fn
	%{method: :post, url: "http://42.site:42/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 42"}}

	%{method: :post, url: "http://42.site/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 80"}}
	end)

	actor = insert(:user)

	assert {:ok, %{body: "port 42"}} =
	Publisher.publish_one(%{
	inbox: inbox42,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: true
	})

	assert {:ok, %{body: "port 80"}} =
	Publisher.publish_one(%{
	inbox: inbox80,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: true
	})
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is not specified",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is set",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_reachable` on successful federation if `unreachable_since` is nil",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: nil
	})

	refute called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_unreachable` on target inbox on non-2xx HTTP response code",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://404.site/users/nick1/inbox"

	assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "it calls `Instances.set_unreachable` on target inbox on request error of any kind",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert capture_log(fn ->
	assert {:error, _} =
	Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
	end) =~ "connrefused"

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target is reachable",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	refute called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target instance has non-nil `unreachable_since`",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert capture_log(fn ->
	assert {:error, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})
	end) =~ "connrefused"

	refute called(Instances.set_unreachable(inbox))
	end
	end

	describe "publish/2" do
	test_with_mock "publishes an activity with BCC to all relevant peers.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox",
	ap_enabled: true
	})

	actor = insert(:user, follower_address: follower.ap_id)
	user = insert(:user)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)

	note_activity =
	insert(:note_activity,
	recipients: [follower.ap_id],
	data_attrs: %{"bcc" => [user.ap_id]}
	)

	res = Publisher.publish(actor, note_activity)
	assert res == :ok

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: note_activity.data["id"]
	})
	)
	end

	test_with_mock "publishes a delete activity to peers who signed fetch requests to the create acitvity/object.",
	Pleroma.Web.Federator.Publisher,
	[:passthrough],
	[] do
	fetcher =
	insert(:user,
	local: false,
	inbox: "https://domain.com/users/nick1/inbox",
	ap_enabled: true
	)

	another_fetcher =
	insert(:user,
	local: false,
	inbox: "https://domain2.com/users/nick1/inbox",
	ap_enabled: true
	)

	actor = insert(:user)

	note_activity = insert(:note_activity, user: actor)
	object = Object.normalize(note_activity, fetch: false)

	activity_path = String.trim_leading(note_activity.data["id"], Pleroma.Web.Endpoint.url())
	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, fetcher)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, another_fetcher)
	\|> get(activity_path)
	\|> json_response(200)

	{:ok, delete} = CommonAPI.delete(note_activity.id, actor)

	res = Publisher.publish(actor, delete)
	assert res == :ok

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain.com/users/nick1/inbox",
	actor_id: actor.id,
	id: delete.data["id"]
	})
	)

	assert called(
	Pleroma.Web.Federator.Publisher.enqueue_one(Publisher, %{
	inbox: "https://domain2.com/users/nick1/inbox",
	actor_id: actor.id,
	id: delete.data["id"]
	})
	)
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs b/test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs
	index 8c7b63f34..3a3199697 100644
	--- a/test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/o_auth_app_controller_test.exs
	@@ -1,219 +1,219 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.OAuthAppControllerTest do
	use Pleroma.Web.ConnCase, async: true
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory

	alias Pleroma.Web

	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 "POST /api/pleroma/admin/oauth_app" do
	test "errors", %{conn: conn} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/oauth_app", %{})
	\|> json_response_and_validate_schema(400)

	assert %{
	"error" => "Missing field: name. Missing field: redirect_uris."
	} = response
	end

	test "success", %{conn: conn} do
	- base_url = Web.base_url()
	+ base_url = Web.Endpoint.url()
	app_name = "Trusted app"

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/oauth_app", %{
	name: app_name,
	redirect_uris: base_url
	})
	\|> json_response_and_validate_schema(200)

	assert %{
	"client_id" => _,
	"client_secret" => _,
	"name" => ^app_name,
	"redirect_uri" => ^base_url,
	"trusted" => false
	} = response
	end

	test "with trusted", %{conn: conn} do
	- base_url = Web.base_url()
	+ base_url = Web.Endpoint.url()
	app_name = "Trusted app"

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/oauth_app", %{
	name: app_name,
	redirect_uris: base_url,
	trusted: true
	})
	\|> json_response_and_validate_schema(200)

	assert %{
	"client_id" => _,
	"client_secret" => _,
	"name" => ^app_name,
	"redirect_uri" => ^base_url,
	"trusted" => true
	} = response
	end
	end

	describe "GET /api/pleroma/admin/oauth_app" do
	setup do
	app = insert(:oauth_app)
	{:ok, app: app}
	end

	test "list", %{conn: conn} do
	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app")
	\|> json_response_and_validate_schema(200)

	assert %{"apps" => apps, "count" => count, "page_size" => _} = response

	assert length(apps) == count
	end

	test "with page size", %{conn: conn} do
	insert(:oauth_app)
	page_size = 1

	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app?page_size=#{page_size}")
	\|> json_response_and_validate_schema(200)

	assert %{"apps" => apps, "count" => _, "page_size" => ^page_size} = response

	assert length(apps) == page_size
	end

	test "search by client name", %{conn: conn, app: app} do
	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app?name=#{app.client_name}")
	\|> json_response_and_validate_schema(200)

	assert %{"apps" => [returned], "count" => _, "page_size" => _} = response

	assert returned["client_id"] == app.client_id
	assert returned["name"] == app.client_name
	end

	test "search by client id", %{conn: conn, app: app} do
	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app?client_id=#{app.client_id}")
	\|> json_response_and_validate_schema(200)

	assert %{"apps" => [returned], "count" => _, "page_size" => _} = response

	assert returned["client_id"] == app.client_id
	assert returned["name"] == app.client_name
	end

	test "only trusted", %{conn: conn} do
	app = insert(:oauth_app, trusted: true)

	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app?trusted=true")
	\|> json_response_and_validate_schema(200)

	assert %{"apps" => [returned], "count" => _, "page_size" => _} = response

	assert returned["client_id"] == app.client_id
	assert returned["name"] == app.client_name
	end
	end

	describe "DELETE /api/pleroma/admin/oauth_app/:id" do
	test "with id", %{conn: conn} do
	app = insert(:oauth_app)

	response =
	conn
	\|> delete("/api/pleroma/admin/oauth_app/" <> to_string(app.id))
	\|> json_response_and_validate_schema(:no_content)

	assert response == ""
	end

	test "with non existance id", %{conn: conn} do
	response =
	conn
	\|> delete("/api/pleroma/admin/oauth_app/0")
	\|> json_response_and_validate_schema(:bad_request)

	assert response == ""
	end
	end

	describe "PATCH /api/pleroma/admin/oauth_app/:id" do
	test "with id", %{conn: conn} do
	app = insert(:oauth_app)

	name = "another name"
	url = "https://example.com"
	scopes = ["admin"]
	id = app.id
	website = "http://website.com"

	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/oauth_app/#{id}", %{
	name: name,
	trusted: true,
	redirect_uris: url,
	scopes: scopes,
	website: website
	})
	\|> json_response_and_validate_schema(200)

	assert %{
	"client_id" => _,
	"client_secret" => _,
	"id" => ^id,
	"name" => ^name,
	"redirect_uri" => ^url,
	"trusted" => true,
	"website" => ^website
	} = response
	end

	test "without id", %{conn: conn} do
	response =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> patch("/api/pleroma/admin/oauth_app/0")
	\|> json_response_and_validate_schema(:bad_request)

	assert response == ""
	end
	end
	end
	diff --git a/test/pleroma/web/admin_api/controllers/user_controller_test.exs b/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	index beb8a5d58..679d4275d 100644
	--- a/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	+++ b/test/pleroma/web/admin_api/controllers/user_controller_test.exs
	@@ -1,914 +1,914 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.UserControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory

	alias Pleroma.HTML
	alias Pleroma.ModerationLog
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MediaProxy

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

	:ok
	end

	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

	test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	clear_config([:admin_token], "password123")

	user = insert(:user)

	conn = get(build_conn(), "/api/pleroma/admin/users/#{user.nickname}?admin_token=password123")

	assert json_response(conn, 200)
	end

	test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
	%{admin: admin} do
	user = insert(:user)
	url = "/api/pleroma/admin/users/#{user.nickname}"

	good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
	good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])

	bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
	bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
	bad_token3 = nil

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, 200)
	end

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, nil)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end

	for bad_token <- [bad_token1, bad_token2, bad_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, bad_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end
	end

	describe "DELETE /api/pleroma/admin/users" do
	test "single user", %{admin: admin, conn: conn} do
	clear_config([:instance, :federating], true)

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://someurl"}]},
	banner: %{"url" => [%{"href" => "https://somebanner"}]},
	bio: "Hello world!",
	name: "A guy"
	)

	# Create some activities to check they got deleted later
	follower = insert(:user)
	{:ok, _} = CommonAPI.post(user, %{status: "test"})
	{:ok, _, _, _} = CommonAPI.follow(user, follower)
	{:ok, _, _, _} = CommonAPI.follow(follower, user)
	user = Repo.get(User, user.id)
	assert user.note_count == 1
	assert user.follower_count == 1
	assert user.following_count == 1
	assert user.is_active

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end,
	perform: fn _, _ -> nil end do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")

	ObanHelpers.perform_all()

	refute User.get_by_nickname(user.nickname).is_active

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user.nickname}"

	assert json_response(conn, 200) == [user.nickname]

	user = Repo.get(User, user.id)
	refute user.is_active

	assert user.avatar == %{}
	assert user.banner == %{}
	assert user.note_count == 0
	assert user.follower_count == 0
	assert user.following_count == 0
	assert user.bio == ""
	assert user.name == nil

	assert called(Pleroma.Web.Federator.publish(:_))
	end
	end

	test "multiple users", %{admin: admin, conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user_one.nickname}, @#{user_two.nickname}"

	response = json_response(conn, 200)
	assert response -- [user_one.nickname, user_two.nickname] == []
	end
	end

	describe "/api/pleroma/admin/users" do
	test "Create", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	},
	%{
	"nickname" => "lain2",
	"email" => "lain2@example.org",
	"password" => "test"
	}
	]
	})

	response = json_response(conn, 200) \|> Enum.map(&Map.get(&1, "type"))
	assert response == ["success", "success"]

	log_entry = Repo.one(ModerationLog)

	assert ["lain", "lain2"] -- Enum.map(log_entry.data["subjects"], & &1["nickname"]) == []
	end

	test "Cannot create user with existing email", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	}
	]
	end

	test "Cannot create user with existing nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => user.nickname,
	"email" => "someuser@plerama.social",
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => "someuser@plerama.social",
	"nickname" => user.nickname
	},
	"error" => "nickname has already been taken",
	"type" => "error"
	}
	]
	end

	test "Multiple user creation works in transaction", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "newuser",
	"email" => "newuser@pleroma.social",
	"password" => "test"
	},
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	},
	%{
	"code" => 409,
	"data" => %{
	"email" => "newuser@pleroma.social",
	"nickname" => "newuser"
	},
	"error" => "",
	"type" => "error"
	}
	]

	assert User.get_by_nickname("newuser") === nil
	end
	end

	describe "/api/pleroma/admin/users/:nickname" do
	test "Show", %{conn: conn} do
	user = insert(:user)

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")

	assert user_response(user) == json_response(conn, 200)
	end

	test "when the user doesn't exist", %{conn: conn} do
	user = build(:user)

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")

	assert %{"error" => "Not found"} == json_response(conn, 404)
	end
	end

	describe "/api/pleroma/admin/users/follow" do
	test "allows to force-follow another user", %{admin: admin, conn: conn} do
	user = insert(:user)
	follower = insert(:user)

	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/follow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, user)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
	end
	end

	describe "/api/pleroma/admin/users/unfollow" do
	test "allows to force-unfollow another user", %{admin: admin, conn: conn} do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/unfollow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
	end
	end

	describe "GET /api/pleroma/admin/users" do
	test "renders users array for the first page", %{conn: conn, admin: admin} do
	user = insert(:user, local: false, tags: ["foo", "bar"])
	user2 = insert(:user, is_approved: false, registration_reason: "I'm a chill dude")

	conn = get(conn, "/api/pleroma/admin/users?page=1")

	users =
	[
	user_response(
	admin,
	%{"roles" => %{"admin" => true, "moderator" => false}}
	),
	user_response(user, %{"local" => false, "tags" => ["foo", "bar"]}),
	user_response(
	user2,
	%{
	"local" => true,
	"is_approved" => false,
	"registration_reason" => "I'm a chill dude",
	"actor_type" => "Person"
	}
	)
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	end

	test "pagination works correctly with service users", %{conn: conn} do
	- service1 = User.get_or_create_service_actor_by_ap_id(Web.base_url() <> "/meido", "meido")
	+ service1 = User.get_or_create_service_actor_by_ap_id(Web.Endpoint.url() <> "/meido", "meido")

	insert_list(25, :user)

	assert %{"count" => 26, "page_size" => 10, "users" => users1} =
	conn
	\|> get("/api/pleroma/admin/users?page=1&filters=", %{page_size: "10"})
	\|> json_response(200)

	assert Enum.count(users1) == 10
	assert service1 not in users1

	assert %{"count" => 26, "page_size" => 10, "users" => users2} =
	conn
	\|> get("/api/pleroma/admin/users?page=2&filters=", %{page_size: "10"})
	\|> json_response(200)

	assert Enum.count(users2) == 10
	assert service1 not in users2

	assert %{"count" => 26, "page_size" => 10, "users" => users3} =
	conn
	\|> get("/api/pleroma/admin/users?page=3&filters=", %{page_size: "10"})
	\|> json_response(200)

	assert Enum.count(users3) == 6
	assert service1 not in users3
	end

	test "renders empty array for the second page", %{conn: conn} do
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?page=2")

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => []
	}
	end

	test "regular search", %{conn: conn} do
	user = insert(:user, nickname: "bob")

	conn = get(conn, "/api/pleroma/admin/users?query=bo")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user, %{"local" => true})]
	}
	end

	test "search by domain", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=domain.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by full nickname", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by display name", %{conn: conn} do
	user = insert(:user, name: "Display name")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?name=display")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "search by email", %{conn: conn} do
	user = insert(:user, email: "email@example.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "regular search with page size", %{conn: conn} do
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")

	assert json_response(conn1, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [user_response(user)]
	}

	conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")

	assert json_response(conn2, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [user_response(user2)]
	}
	end

	test "only local users" do
	admin = insert(:user, is_admin: true, nickname: "john")
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/users?query=bo&filters=local")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "only local users with no query", %{conn: conn, admin: old_admin} do
	admin = insert(:user, is_admin: true, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn = get(conn, "/api/pleroma/admin/users?filters=local")

	users =
	[
	user_response(user),
	user_response(admin, %{
	"roles" => %{"admin" => true, "moderator" => false}
	}),
	user_response(old_admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	})
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	end

	test "only unconfirmed users", %{conn: conn} do
	sad_user = insert(:user, nickname: "sadboy", is_confirmed: false)
	old_user = insert(:user, nickname: "oldboy", is_confirmed: false)

	insert(:user, nickname: "happyboy", is_approved: true)
	insert(:user, is_confirmed: true)

	result =
	conn
	\|> get("/api/pleroma/admin/users?filters=unconfirmed")
	\|> json_response(200)

	users =
	Enum.map([old_user, sad_user], fn user ->
	user_response(user, %{
	"is_confirmed" => false,
	"is_approved" => true
	})
	end)
	\|> Enum.sort_by(& &1["nickname"])

	assert result == %{"count" => 2, "page_size" => 50, "users" => users}
	end

	test "only unapproved users", %{conn: conn} do
	user =
	insert(:user,
	nickname: "sadboy",
	is_approved: false,
	registration_reason: "Plz let me in!"
	)

	insert(:user, nickname: "happyboy", is_approved: true)

	conn = get(conn, "/api/pleroma/admin/users?filters=need_approval")

	users = [
	user_response(
	user,
	%{"is_approved" => false, "registration_reason" => "Plz let me in!"}
	)
	]

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only admins", %{conn: conn, admin: admin} do
	second_admin = insert(:user, is_admin: true)
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")

	users =
	[
	user_response(admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	}),
	user_response(second_admin, %{
	"is_active" => true,
	"roles" => %{"admin" => true, "moderator" => false}
	})
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only moderators", %{conn: conn} do
	moderator = insert(:user, is_moderator: true)
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	user_response(moderator, %{
	"is_active" => true,
	"roles" => %{"admin" => false, "moderator" => true}
	})
	]
	}
	end

	test "load users with actor_type is Person", %{admin: admin, conn: conn} do
	insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")

	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> get(user_path(conn, :list), %{actor_types: ["Person"]})
	\|> json_response(200)

	users =
	[
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}}),
	user_response(user1),
	user_response(user2)
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert response == %{"count" => 3, "page_size" => 50, "users" => users}
	end

	test "load users with actor_type is Person and Service", %{admin: admin, conn: conn} do
	user_service = insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")

	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> get(user_path(conn, :list), %{actor_types: ["Person", "Service"]})
	\|> json_response(200)

	users =
	[
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}}),
	user_response(user1),
	user_response(user2),
	user_response(user_service, %{"actor_type" => "Service"})
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert response == %{"count" => 4, "page_size" => 50, "users" => users}
	end

	test "load users with actor_type is Service", %{conn: conn} do
	user_service = insert(:user, actor_type: "Service")
	insert(:user, actor_type: "Application")
	insert(:user)
	insert(:user)

	response =
	conn
	\|> get(user_path(conn, :list), %{actor_types: ["Service"]})
	\|> json_response(200)

	users = [user_response(user_service, %{"actor_type" => "Service"})]

	assert response == %{"count" => 1, "page_size" => 50, "users" => users}
	end

	test "load users with tags list", %{conn: conn} do
	user1 = insert(:user, tags: ["first"])
	user2 = insert(:user, tags: ["second"])
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")

	users =
	[
	user_response(user1, %{"tags" => ["first"]}),
	user_response(user2, %{"tags" => ["second"]})
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "`active` filters out users pending approval", %{token: token} do
	insert(:user, is_approved: false)
	%{id: user_id} = insert(:user, is_approved: true)
	%{id: admin_id} = token.user

	conn =
	build_conn()
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/users?filters=active")

	assert %{
	"count" => 2,
	"page_size" => 50,
	"users" => [
	%{"id" => ^admin_id},
	%{"id" => ^user_id}
	]
	} = json_response(conn, 200)
	end

	test "it works with multiple filters" do
	admin = insert(:user, nickname: "john", is_admin: true)
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob", local: false, is_active: false)

	insert(:user, nickname: "ken", local: true, is_active: false)
	insert(:user, nickname: "bobb", local: false, is_active: true)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> get("/api/pleroma/admin/users?filters=deactivated,external")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [user_response(user)]
	}
	end

	test "it omits relay user", %{admin: admin, conn: conn} do
	assert %User{} = Relay.get_actor()

	conn = get(conn, "/api/pleroma/admin/users")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}})
	]
	}
	end
	end

	test "PATCH /api/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
	user_one = insert(:user, is_active: false)
	user_two = insert(:user, is_active: false)

	conn =
	patch(
	conn,
	"/api/pleroma/admin/users/activate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response(conn, 200)
	assert Enum.map(response["users"], & &1["is_active"]) == [true, true]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
	user_one = insert(:user, is_active: true)
	user_two = insert(:user, is_active: true)

	conn =
	patch(
	conn,
	"/api/pleroma/admin/users/deactivate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response(conn, 200)
	assert Enum.map(response["users"], & &1["is_active"]) == [false, false]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/approve", %{admin: admin, conn: conn} do
	user_one = insert(:user, is_approved: false)
	user_two = insert(:user, is_approved: false)

	conn =
	patch(
	conn,
	"/api/pleroma/admin/users/approve",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response(conn, 200)
	assert Enum.map(response["users"], & &1["is_approved"]) == [true, true]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} approved users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation", %{admin: admin, conn: conn} do
	user = insert(:user)

	conn = patch(conn, "/api/pleroma/admin/users/#{user.nickname}/toggle_activation")

	assert json_response(conn, 200) ==
	user_response(
	user,
	%{"is_active" => !user.is_active}
	)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user.nickname}"
	end

	defp user_response(user, attrs \\ %{}) do
	%{
	"is_active" => user.is_active,
	"id" => user.id,
	"email" => user.email,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user.local,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname),
	"is_confirmed" => true,
	"is_approved" => true,
	"url" => user.ap_id,
	"registration_reason" => nil,
	"actor_type" => "Person"
	}
	\|> Map.merge(attrs)
	end
	end
	diff --git a/test/pleroma/web/common_api_test.exs b/test/pleroma/web/common_api_test.exs
	index adfe58def..5ab3a48ad 100644
	--- a/test/pleroma/web/common_api_test.exs
	+++ b/test/pleroma/web/common_api_test.exs
	@@ -1,1433 +1,1433 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory
	import Mock
	import Ecto.Query, only: [from: 2]

	require Pleroma.Constants

	setup do: clear_config([:instance, :safe_dm_mentions])
	setup do: clear_config([:instance, :limit])
	setup do: clear_config([:instance, :max_pinned_statuses])

	describe "posting polls" do
	test "it posts a poll" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "who is the best",
	poll: %{expires_in: 600, options: ["reimu", "marisa"]}
	})

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

	assert object.data["type"] == "Question"
	assert object.data["oneOf"] \|> length() == 2
	end
	end

	describe "blocking" do
	setup do
	blocker = insert(:user)
	blocked = insert(:user)
	User.follow(blocker, blocked)
	User.follow(blocked, blocker)
	%{blocker: blocker, blocked: blocked}
	end

	test "it blocks and federates", %{blocker: blocker, blocked: blocked} do
	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, block} = CommonAPI.block(blocker, blocked)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	assert called(Pleroma.Web.Federator.publish(block))
	end
	end

	test "it blocks and does not federate if outgoing blocks are disabled", %{
	blocker: blocker,
	blocked: blocked
	} do
	clear_config([:instance, :federating], true)
	clear_config([:activitypub, :outgoing_blocks], false)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, block} = CommonAPI.block(blocker, blocked)

	assert block.local
	assert User.blocks?(blocker, blocked)
	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	refute called(Pleroma.Web.Federator.publish(block))
	end
	end
	end

	describe "posting chat messages" do
	setup do: clear_config([:instance, :chat_limit])

	test "it posts a self-chat" do
	author = insert(:user)
	recipient = author

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"remember to buy milk when milk truk arive"
	)

	assert activity.data["type"] == "Create"
	end

	test "it posts a chat message without content but with an attachment" do
	author = insert(:user)
	recipient = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

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

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ ->
	nil
	end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	nil,
	media_id: upload.id
	)

	notification =
	Notification.for_user_and_activity(recipient, activity)
	\|> Repo.preload(:activity)

	assert called(Pleroma.Web.Push.send(notification))
	assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], notification))
	assert called(Pleroma.Web.Streamer.stream(["user", "user:pleroma_chat"], :_))

	assert activity
	end
	end

	test "it adds html newlines" do
	author = insert(:user)
	recipient = insert(:user)

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"uguu\nuguuu"
	)

	assert other_user.ap_id not in activity.recipients

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

	assert object.data["content"] == "uguu<br/>uguuu"
	end

	test "it linkifies" do
	author = insert(:user)
	recipient = insert(:user)

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"https://example.org is the site of @#{other_user.nickname} #2hu"
	)

	assert other_user.ap_id not in activity.recipients

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

	assert object.data["content"] ==
	"<a href=\"https://example.org\" rel=\"ugc\">https://example.org</a> is the site of <span class=\"h-card\"><a class=\"u-url mention\" data-user=\"#{
	other_user.id
	}\" href=\"#{other_user.ap_id}\" rel=\"ugc\">@<span>#{other_user.nickname}</span></a></span> <a class=\"hashtag\" data-tag=\"2hu\" href=\"http://localhost:4001/tag/2hu\">#2hu</a>"
	end

	test "it posts a chat message" do
	author = insert(:user)
	recipient = insert(:user)

	{:ok, activity} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"a test message <script>alert('uuu')</script> :firefox:"
	)

	assert activity.data["type"] == "Create"
	assert activity.local
	object = Object.normalize(activity, fetch: false)

	assert object.data["type"] == "ChatMessage"
	assert object.data["to"] == [recipient.ap_id]

	assert object.data["content"] ==
	"a test message <script>alert('uuu')</script> :firefox:"

	assert object.data["emoji"] == %{
	"firefox" => "http://localhost:4001/emoji/Firefox.gif"
	}

	assert Chat.get(author.id, recipient.ap_id)
	assert Chat.get(recipient.id, author.ap_id)

	assert :ok == Pleroma.Web.Federator.perform(:publish, activity)
	end

	test "it reject messages over the local limit" do
	clear_config([:instance, :chat_limit], 2)

	author = insert(:user)
	recipient = insert(:user)

	{:error, message} =
	CommonAPI.post_chat_message(
	author,
	recipient,
	"123"
	)

	assert message == :content_too_long
	end

	test "it reject messages via MRF" do
	clear_config([:mrf_keyword, :reject], ["GNO"])
	clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])

	author = insert(:user)
	recipient = insert(:user)

	assert {:reject, "[KeywordPolicy] Matches with rejected keyword"} ==
	CommonAPI.post_chat_message(author, recipient, "GNO/Linux")
	end
	end

	describe "unblocking" do
	test "it works even without an existing block activity" do
	blocked = insert(:user)
	blocker = insert(:user)
	User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	assert {:ok, :no_activity} == CommonAPI.unblock(blocker, blocked)
	refute User.blocks?(blocker, blocked)
	end
	end

	describe "deletion" do
	test "it works with pruned objects" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	clear_config([:instance, :federating], true)

	Object.normalize(post, fetch: false)
	\|> Object.prune()

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it allows users to delete their posts" do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, user)
	assert delete.local
	assert called(Pleroma.Web.Federator.publish(delete))
	end

	refute Activity.get_by_id(post.id)
	end

	test "it does not allow a user to delete their posts" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:error, "Could not delete"} = CommonAPI.delete(post.id, other_user)
	assert Activity.get_by_id(post.id)
	end

	test "it allows moderators to delete other user's posts" do
	user = insert(:user)
	moderator = insert(:user, is_moderator: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end

	test "it allows admins to delete other user's posts" do
	user = insert(:user)
	moderator = insert(:user, is_admin: true)

	{:ok, post} = CommonAPI.post(user, %{status: "namu amida butsu"})

	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local

	refute Activity.get_by_id(post.id)
	end

	test "superusers deleting non-local posts won't federate the delete" do
	# This is the user of the ingested activity
	_user =
	insert(:user,
	local: false,
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: NaiveDateTime.utc_now()
	)

	moderator = insert(:user, is_admin: true)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	{:ok, post} = Transmogrifier.handle_incoming(data)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	assert {:ok, delete} = CommonAPI.delete(post.id, moderator)
	assert delete.local
	refute called(Pleroma.Web.Federator.publish(:_))
	end

	refute Activity.get_by_id(post.id)
	end
	end

	test "favoriting race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.favorite(user, activity.id)
	end)

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

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.favorite(user, activity.id)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["like_count"] == 20
	end

	test "repeating race condition" do
	user = insert(:user)
	users_serial = insert_list(10, :user)
	users = insert_list(10, :user)

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

	users_serial
	\|> Enum.map(fn user ->
	CommonAPI.repeat(activity.id, user)
	end)

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

	users
	\|> Enum.map(fn user ->
	Task.async(fn ->
	CommonAPI.repeat(activity.id, user)
	end)
	end)
	\|> Enum.map(&Task.await/1)

	object = Object.get_by_ap_id(activity.data["object"])
	assert object.data["announcement_count"] == 20
	end

	test "when replying to a conversation / participation, it will set the correct context id even if no explicit reply_to is given" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	[participation] = Participation.for_user(user)

	{:ok, convo_reply} =
	CommonAPI.post(user, %{status: ".", in_reply_to_conversation_id: participation.id})

	assert Visibility.is_direct?(convo_reply)

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

	test "when replying to a conversation / participation, it only mentions the recipients explicitly declared in the participation" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey",
	visibility: "direct"
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients

	[participation] = Participation.for_user(har)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "I don't really like @#{tridi.nickname}",
	visibility: "direct",
	in_reply_to_status_id: activity.id,
	in_reply_to_conversation_id: participation.id
	})

	assert har.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	refute tridi.ap_id in activity.recipients
	end

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)

	clear_config([:instance, :safe_dm_mentions], true)

	{:ok, activity} =
	CommonAPI.post(har, %{
	status: "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	visibility: "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU"})

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

	assert object.data["tag"] == ["2hu"]
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ":firefox:"})

	assert Object.normalize(activity, fetch: false).data["emoji"]["firefox"]
	end

	describe "posting" do
	test "it adds an emoji on an external site" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey :external_emoji:"})

	assert %{"external_emoji" => url} = Object.normalize(activity).data["emoji"]
	assert url == "https://example.com/emoji.png"

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

	assert %{"blank" => url} = Object.normalize(activity).data["emoji"]
	- assert url == "#{Pleroma.Web.base_url()}/emoji/blank.png"
	+ assert url == "#{Pleroma.Web.Endpoint.url()}/emoji/blank.png"
	end

	test "deactivated users can't post" do
	user = insert(:user, is_active: false)
	assert {:error, _} = CommonAPI.post(user, %{status: "ye"})
	end

	test "it supports explicit addressing" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)
	user_four = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"Hey, I think @#{user_three.nickname} is ugly. @#{user_four.nickname} is alright though.",
	to: [user_two.nickname, user_four.nickname, "nonexistent"]
	})

	assert user.ap_id in activity.recipients
	assert user_two.ap_id in activity.recipients
	assert user_four.ap_id in activity.recipients
	refute user_three.ap_id in activity.recipients
	end

	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/html"
	})

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

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	assert object.data["source"] == post
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: post,
	content_type: "text/markdown"
	})

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

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	assert object.data["source"] == post
	end

	test "it does not allow replies to direct messages that are not direct messages themselves" do
	user = insert(:user)

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

	assert {:ok, _} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: "direct",
	in_reply_to_status_id: activity.id
	})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	assert {:error, "The message visibility must be direct"} =
	CommonAPI.post(user, %{
	status: "suya..",
	visibility: visibility,
	in_reply_to_status_id: activity.id
	})
	end)
	end

	test "replying with a direct message will NOT auto-add the author of the reply to the recipient list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "I'm stupid"})

	{:ok, open_answer} =
	CommonAPI.post(other_user, %{status: "No ur smart", in_reply_to_status_id: post.id})

	# The OP is implicitly added
	assert user.ap_id in open_answer.recipients

	{:ok, secret_answer} =
	CommonAPI.post(other_user, %{
	status: "lol, that guy really is stupid, right, @#{third_user.nickname}?",
	in_reply_to_status_id: post.id,
	visibility: "direct"
	})

	assert third_user.ap_id in secret_answer.recipients

	# The OP is not added
	refute user.ap_id in secret_answer.recipients
	end

	test "it allows to address a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

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

	assert activity.data["bcc"] == [list.ap_id]
	assert activity.recipients == [list.ap_id, user.ap_id]
	assert activity.data["listMessage"] == list.ap_id
	end

	test "it returns error when status is empty and no attachments" do
	user = insert(:user)

	assert {:error, "Cannot post an empty status without attachments"} =
	CommonAPI.post(user, %{status: ""})
	end

	test "it validates character limits are correctly enforced" do
	clear_config([:instance, :limit], 5)

	user = insert(:user)

	assert {:error, "The status is over the character limit"} =
	CommonAPI.post(user, %{status: "foobar"})

	assert {:ok, _activity} = CommonAPI.post(user, %{status: "12345"})
	end

	test "it can handle activities that expire" do
	user = insert(:user)

	expires_at = DateTime.add(DateTime.utc_now(), 1_000_000)

	assert {:ok, activity} = CommonAPI.post(user, %{status: "chai", expires_in: 1_000_000})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at: expires_at
	)
	end
	end

	describe "reactions" do
	test "reacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert reaction.data["actor"] == user.ap_id
	assert reaction.data["content"] == "👍"

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

	{:error, _} = CommonAPI.react_with_emoji(activity.id, user, ".")
	end

	test "unreacting to a status with an emoji" do
	user = insert(:user)
	other_user = insert(:user)

	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	{:ok, unreaction} = CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert unreaction.data["type"] == "Undo"
	assert unreaction.data["object"] == reaction.data["id"]
	assert unreaction.local

	# On federation, it contains the undone (and deleted) object
	unreaction_with_object = %{
	unreaction
	\| data: Map.put(unreaction.data, "object", reaction.data)
	}

	assert called(Pleroma.Web.Federator.publish(unreaction_with_object))
	end
	end

	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, user)
	assert Visibility.is_public?(announce_activity)
	end

	test "can't repeat a repeat" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, other_user)

	refute match?({:ok, %Activity{}}, CommonAPI.repeat(announce.id, user))
	end

	test "repeating a status privately" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{} = announce_activity} =
	CommonAPI.repeat(activity.id, user, %{visibility: "private"})

	assert Visibility.is_private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)
	end

	test "author can repeat own private statuses" do
	author = insert(:user)
	follower = insert(:user)
	CommonAPI.follow(follower, author)

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

	{:ok, %Activity{} = announce_activity} = CommonAPI.repeat(activity.id, author)

	assert Visibility.is_private?(announce_activity)
	refute Visibility.visible_for_user?(announce_activity, nil)

	assert Visibility.visible_for_user?(activity, follower)
	assert {:error, :not_found} = CommonAPI.repeat(activity.id, follower)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, post_activity} = CommonAPI.post(other_user, %{status: "cofe"})

	{:ok, %Activity{data: data}} = CommonAPI.favorite(user, post_activity.id)
	assert data["type"] == "Like"
	assert data["actor"] == user.ap_id
	assert data["object"] == post_activity.data["object"]
	end

	test "retweeting a status twice returns the status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{} = announce} = CommonAPI.repeat(activity.id, user)
	{:ok, ^announce} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns ok, but without the like activity" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe"})
	{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)
	assert {:ok, :already_liked} = CommonAPI.favorite(user, activity.id)
	end
	end

	describe "pinned statuses" do
	setup do
	clear_config([:instance, :max_pinned_statuses], 1)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})

	[user: user, activity: activity]
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{pinned_activities: [^id]} = user
	end

	test "pin poll", %{user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How is fediverse today?",
	poll: %{options: ["Absolutely outstanding", "Not good"], expires_in: 20}
	})

	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{pinned_activities: [^id]} = user
	end

	test "unlisted statuses can be pinned", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!", visibility: "unlisted"})
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, "Could not pin"} = CommonAPI.pin(activity.id, user)
	end

	test "max pinned statuses", %{user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, "You have already pinned the maximum number of statuses"} =
	CommonAPI.pin(activity_two.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	id = activity.id

	assert match?({:ok, %{id: ^id}}, CommonAPI.unpin(activity.id, user))

	user = refresh_record(user)

	assert %User{pinned_activities: []} = user
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, _} = CommonAPI.delete(activity.id, user)

	user = refresh_record(user)

	assert %User{pinned_activities: []} = user
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "marks notifications as read after mute" do
	author = insert(:user)
	activity = insert(:note_activity, user: author)

	friend1 = insert(:user)
	friend2 = insert(:user)

	{:ok, reply_activity} =
	CommonAPI.post(
	friend2,
	%{
	status: "@#{author.nickname} @#{friend1.nickname} test reply",
	in_reply_to_status_id: activity.id
	}
	)

	{:ok, favorite_activity} = CommonAPI.favorite(friend2, activity.id)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, friend1)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	unread_notifications =
	Repo.all(from(n in Notification, where: n.seen == false, where: n.user_id == ^author.id))

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(unread_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)

	{:ok, _} = CommonAPI.add_mute(author, activity)
	assert CommonAPI.thread_muted?(author, activity)

	assert Repo.aggregate(
	from(n in Notification, where: n.seen == false and n.user_id == ^friend1.id),
	:count
	) == 1

	read_notifications =
	Repo.all(from(n in Notification, where: n.seen == true, where: n.user_id == ^author.id))

	assert Enum.any?(read_notifications, fn n ->
	n.type == "favourite" && n.activity_id == favorite_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "reblog" && n.activity_id == repeat_activity.id
	end)

	assert Enum.any?(read_notifications, fn n ->
	n.type == "mention" && n.activity_id == reply_activity.id
	end)
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)
	assert CommonAPI.thread_muted?(user, activity)
	end

	test "add expiring mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity, %{expires_in: 60})
	assert CommonAPI.thread_muted?(user, activity)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unmute_conversation", "user_id" => user.id, "activity_id" => activity.id}

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user, activity)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute by ids", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user.id, activity.id)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:error, _} = CommonAPI.add_mute(user, activity)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{status: "foobar"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	activity_ap_id = activity.data["id"]
	comment = "foobar"

	report_data = %{
	account_id: target_user.id,
	comment: comment,
	status_ids: [activity.id]
	}

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

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	}
	} = flag_activity
	end

	test "updates report state" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, report} = CommonAPI.update_report_state(report_id, "resolved")

	assert report.data["state"] == "resolved"

	[reported_user, activity_id] = report.data["object"]

	assert reported_user == target_user.ap_id
	assert activity_id == activity.data["id"]
	end

	test "does not update report state when state is unsupported" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	assert CommonAPI.update_report_state(report_id, "test") == {:error, "Unsupported state"}
	end

	test "updates state of multiple reports" do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %Activity{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel offended",
	status_ids: [activity.id]
	})

	{:ok, %Activity{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	account_id: target_user.id,
	comment: "I feel very offended!",
	status_ids: [activity.id]
	})

	{:ok, report_ids} =
	CommonAPI.update_report_state([first_report_id, second_report_id], "resolved")

	first_report = Activity.get_by_id(first_report_id)
	second_report = Activity.get_by_id(second_report_id)

	assert report_ids -- [first_report_id, second_report_id] == []
	assert first_report.data["state"] == "resolved"
	assert second_report.data["state"] == "resolved"
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(muter, muted)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(muter, muted)

	assert User.showing_reblogs?(muter, muted) == true
	end
	end

	describe "follow/2" do
	test "directly follows a non-locked local user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)

	assert User.following?(follower, followed)
	end
	end

	describe "unfollow/2" do
	test "also unsubscribes a user" do
	[follower, followed] = insert_pair(:user)
	{:ok, follower, followed, _} = CommonAPI.follow(follower, followed)
	{:ok, _subscription} = User.subscribe(follower, followed)

	assert User.subscribed_to?(follower, followed)

	{:ok, follower} = CommonAPI.unfollow(follower, followed)

	refute User.subscribed_to?(follower, followed)
	end

	test "cancels a pending follow for a local user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true)

	assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end

	test "cancels a pending follow for a remote user" do
	follower = insert(:user)
	followed = insert(:user, is_locked: true, local: false, ap_enabled: true)

	assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} =
	CommonAPI.follow(follower, followed)

	assert User.get_follow_state(follower, followed) == :follow_pending
	assert {:ok, follower} = CommonAPI.unfollow(follower, followed)
	assert User.get_follow_state(follower, followed) == nil

	assert %{id: ^activity_id, data: %{"state" => "cancelled"}} =
	Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(follower, followed)

	assert %{
	data: %{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "state" => "cancelled"}
	}
	} = Pleroma.Web.ActivityPub.Utils.fetch_latest_undo(follower)
	end
	end

	describe "accept_follow_request/2" do
	test "after acceptance, it sets all existing pending follow request states to 'accept'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_three} = CommonAPI.follow(follower_two, user)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.accept_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "accept"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "after rejection, it sets all existing pending follow request states to 'reject'" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	follower_two = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_three} = CommonAPI.follow(follower_two, user)

	assert follow_activity.data["state"] == "pending"
	assert follow_activity_two.data["state"] == "pending"
	assert follow_activity_three.data["state"] == "pending"

	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)

	assert Repo.get(Activity, follow_activity.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_two.id).data["state"] == "reject"
	assert Repo.get(Activity, follow_activity_three.id).data["state"] == "pending"
	end

	test "doesn't create a following relationship if the corresponding follow request doesn't exist" do
	user = insert(:user, is_locked: true)
	not_follower = insert(:user)
	CommonAPI.accept_follow_request(not_follower, user)

	assert Pleroma.FollowingRelationship.following?(not_follower, user) == false
	end
	end

	describe "vote/3" do
	test "does not allow to vote twice" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

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

	{:ok, _, object} = CommonAPI.vote(other_user, object, [0])

	assert {:error, "Already voted"} == CommonAPI.vote(other_user, object, [1])
	end
	end

	describe "listen/2" do
	test "returns a valid activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	album: "lain radio",
	artist: "lain",
	length: 180_000
	})

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

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "public"
	end

	test "respects visibility=private" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.listen(user, %{
	title: "lain radio episode 1",
	album: "lain radio",
	artist: "lain",
	length: 180_000,
	visibility: "private"
	})

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

	assert object.data["title"] == "lain radio episode 1"

	assert Visibility.get_visibility(activity) == "private"
	end
	end

	describe "get_user/1" do
	test "gets user by ap_id" do
	user = insert(:user)
	assert CommonAPI.get_user(user.ap_id) == user
	end

	test "gets user by guessed nickname" do
	user = insert(:user, ap_id: "", nickname: "mario@mushroom.kingdom")
	assert CommonAPI.get_user("https://mushroom.kingdom/users/mario") == user
	end

	test "fallback" do
	assert %User{
	name: "",
	ap_id: "",
	nickname: "erroruser@example.com"
	} = CommonAPI.get_user("")
	end
	end

	describe "with `local` visibility" do
	setup do: clear_config([:instance, :federating], true)

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

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	{:ok, activity} = CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	assert Visibility.is_local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "delete" do
	user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(user, %{status: "#2hu #2HU", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"deleted_activity_id" => ^activity_id}} = activity} =
	CommonAPI.delete(activity_id, user)

	assert Visibility.is_local_public?(activity)
	assert_not_called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "repeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Announce"}} = activity} =
	CommonAPI.repeat(activity_id, user)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unrepeat" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, %Activity{id: activity_id}} =
	CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	assert {:ok, _} = CommonAPI.repeat(activity_id, user)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unrepeat(activity_id, user)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "favorite" do
	user = insert(:user)
	other_user = insert(:user)

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

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Like"}} = activity} =
	CommonAPI.favorite(user, activity.id)

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unfavorite" do
	user = insert(:user)
	other_user = insert(:user)

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

	{:ok, %Activity{}} = CommonAPI.favorite(user, activity.id)

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, activity} = CommonAPI.unfavorite(activity.id, user)
	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "react_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "EmojiReact"}} = activity} =
	CommonAPI.react_with_emoji(activity.id, user, "👍")

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end

	test "unreact_with_emoji" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(other_user, %{status: "cofe", visibility: "local"})

	{:ok, _reaction} = CommonAPI.react_with_emoji(activity.id, user, "👍")

	with_mock Pleroma.Web.Federator, publish: fn _ -> :ok end do
	assert {:ok, %Activity{data: %{"type" => "Undo"}} = activity} =
	CommonAPI.unreact_with_emoji(activity.id, user, "👍")

	assert Visibility.is_local_public?(activity)
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end
	end
	end
	diff --git a/test/pleroma/web/feed/tag_controller_test.exs b/test/pleroma/web/feed/tag_controller_test.exs
	index 5c9201de1..140cdb8bf 100644
	--- a/test/pleroma/web/feed/tag_controller_test.exs
	+++ b/test/pleroma/web/feed/tag_controller_test.exs
	@@ -1,195 +1,195 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Feed.TagControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import SweetXml

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Feed.FeedView

	setup do: clear_config([:feed])

	test "gets a feed (ATOM)", %{conn: conn} do
	clear_config(
	[:feed, :post_title],
	%{max_length: 25, omission: "..."}
	)

	user = insert(:user)
	{:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})

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

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	{:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})

	{:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})

	response =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.atom"))
	\|> response(200)

	xml = parse(response)

	assert xpath(xml, ~x"//feed/title/text()") == '#pleromaart'

	assert xpath(xml, ~x"//feed/entry/title/text()"l) == [
	'42 This is :moominmamm...',
	'yeah #PleromaArt'
	]

	assert xpath(xml, ~x"//feed/entry/author/name/text()"ls) == [user.nickname, user.nickname]
	assert xpath(xml, ~x"//feed/entry/author/id/text()"ls) == [user.ap_id, user.ap_id]

	conn =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get("/tags/pleromaart.atom", %{"max_id" => activity2.id})

	assert get_resp_header(conn, "content-type") == ["application/atom+xml; charset=utf-8"]
	resp = response(conn, 200)
	xml = parse(resp)

	assert xpath(xml, ~x"//feed/title/text()") == '#pleromaart'

	assert xpath(xml, ~x"//feed/entry/title/text()"l) == [
	'yeah #PleromaArt'
	]
	end

	test "gets a feed (RSS)", %{conn: conn} do
	clear_config(
	[:feed, :post_title],
	%{max_length: 25, omission: "..."}
	)

	user = insert(:user)
	{:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})

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

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	{:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})

	{:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})

	response =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(200)

	xml = parse(response)
	assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'

	assert xpath(xml, ~x"//channel/description/text()"s) ==
	"These are public toots tagged with #pleromaart. You can interact with them if you have an account anywhere in the fediverse."

	assert xpath(xml, ~x"//channel/link/text()") ==
	- '#{Pleroma.Web.base_url()}/tags/pleromaart.rss'
	+ '#{Pleroma.Web.Endpoint.url()}/tags/pleromaart.rss'

	assert xpath(xml, ~x"//channel/webfeeds:logo/text()") ==
	- '#{Pleroma.Web.base_url()}/static/logo.svg'
	+ '#{Pleroma.Web.Endpoint.url()}/static/logo.svg'

	assert xpath(xml, ~x"//channel/item/title/text()"l) == [
	'42 This is :moominmamm...',
	'yeah #PleromaArt'
	]

	assert xpath(xml, ~x"//channel/item/pubDate/text()"sl) == [
	FeedView.pub_date(activity2.data["published"]),
	FeedView.pub_date(activity1.data["published"])
	]

	assert xpath(xml, ~x"//channel/item/enclosure/@url"sl) == [
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	]

	obj1 = Object.normalize(activity1, fetch: false)
	obj2 = Object.normalize(activity2, fetch: false)

	assert xpath(xml, ~x"//channel/item/description/text()"sl) == [
	HtmlEntities.decode(FeedView.activity_content(obj2.data)),
	HtmlEntities.decode(FeedView.activity_content(obj1.data))
	]

	response =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(200)

	xml = parse(response)
	assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'

	assert xpath(xml, ~x"//channel/description/text()"s) ==
	"These are public toots tagged with #pleromaart. You can interact with them if you have an account anywhere in the fediverse."

	conn =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/tags/pleromaart.rss", %{"max_id" => activity2.id})

	assert get_resp_header(conn, "content-type") == ["application/rss+xml; charset=utf-8"]
	resp = response(conn, 200)
	xml = parse(resp)

	assert xpath(xml, ~x"//channel/title/text()") == '#pleromaart'

	assert xpath(xml, ~x"//channel/item/title/text()"l) == [
	'yeah #PleromaArt'
	]
	end

	describe "private instance" do
	setup do: clear_config([:instance, :public], false)

	test "returns 404 for tags feed", %{conn: conn} do
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(404)
	end
	end
	end
	diff --git a/test/pleroma/web/feed/user_controller_test.exs b/test/pleroma/web/feed/user_controller_test.exs
	index 408653d92..f794eaee9 100644
	--- a/test/pleroma/web/feed/user_controller_test.exs
	+++ b/test/pleroma/web/feed/user_controller_test.exs
	@@ -1,249 +1,249 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Feed.UserControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import SweetXml

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Feed.FeedView

	setup do: clear_config([:static_fe, :enabled], false)

	describe "feed" do
	setup do: clear_config([:feed])

	setup do
	clear_config(
	[:feed, :post_title],
	%{max_length: 15, omission: "..."}
	)

	activity = insert(:note_activity)

	note =
	insert(:note,
	data: %{
	"content" => "This & this is :moominmamma: note ",
	"source" => "This & this is :moominmamma: note ",
	"attachment" => [
	%{
	"url" => [
	%{"mediaType" => "image/png", "href" => "https://pleroma.gov/image.png"}
	]
	}
	],
	"inReplyTo" => activity.data["id"],
	"context" => "2hu & as",
	"summary" => "2hu & as"
	}
	)

	note_activity = insert(:note_activity, note: note)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	note2 =
	insert(:note,
	user: user,
	data: %{
	"content" => "42 & This is :moominmamma: note ",
	"inReplyTo" => activity.data["id"]
	}
	)

	note_activity2 = insert(:note_activity, note: note2)
	object = Object.normalize(note_activity, fetch: false)

	[user: user, object: object, max_id: note_activity2.id]
	end

	test "gets an atom feed", %{conn: conn, user: user, object: object, max_id: max_id} do
	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == ['42 & Thi...', 'This & t...']
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get("/users/#{user.nickname}/feed", %{"max_id" => max_id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == ['This & t...']
	end

	test "gets a rss feed", %{conn: conn, user: user, object: object, max_id: max_id} do
	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	assert activity_titles == ['42 & Thi...', 'This & t...']
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])

	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss", %{"max_id" => max_id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	assert activity_titles == ['This & t...']
	end

	test "returns 404 for a missing feed", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, "nonexisting"))

	assert response(conn, 404)
	end

	test "returns feed with public and unlisted activities", %{conn: conn} do
	user = insert(:user)

	{:ok, _} = CommonAPI.post(user, %{status: "public", visibility: "public"})
	{:ok, _} = CommonAPI.post(user, %{status: "direct", visibility: "direct"})
	{:ok, _} = CommonAPI.post(user, %{status: "unlisted", visibility: "unlisted"})
	{:ok, _} = CommonAPI.post(user, %{status: "private", visibility: "private"})

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)
	\|> Enum.sort()

	assert activity_titles == ['public', 'unlisted']
	end

	test "returns 404 when the user is remote", %{conn: conn} do
	user = insert(:user, local: false)

	{:ok, _} = CommonAPI.post(user, %{status: "test"})

	assert conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(404)
	end

	test "does not require authentication on non-federating instances", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "feed_redirect" do
	test "with html format, it redirects to user feed", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	response =
	conn
	\|> get("/users/#{user.nickname}")
	\|> response(200)

	assert response ==
	Pleroma.Web.Fallback.RedirectController.redirector_with_meta(
	conn,
	%{user: user}
	).resp_body
	end

	test "with html format, it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == %{"error" => "Not found"}
	end

	test "with non-html / non-json format, it redirects to user feed in atom format", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/users/#{user.nickname}")

	assert conn.status == 302
	- assert redirected_to(conn) == "#{Pleroma.Web.base_url()}/users/#{user.nickname}/feed.atom"
	+ assert redirected_to(conn) == "#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}/feed.atom"
	end

	test "with non-html / non-json format, it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get(user_feed_path(conn, :feed, "jimm"))
	\|> response(404)

	assert response == ~S({"error":"Not found"})
	end
	end

	describe "private instance" do
	setup do: clear_config([:instance, :public])

	test "returns 404 for user feed", %{conn: conn} do
	clear_config([:instance, :public], false)
	user = insert(:user)

	{:ok, _} = CommonAPI.post(user, %{status: "test"})

	assert conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(404)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	index b99856659..f137743be 100644
	--- a/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	@@ -1,94 +1,94 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.InstanceControllerTest do
	# TODO: Should not need Cachex
	use Pleroma.Web.ConnCase

	alias Pleroma.User
	import Pleroma.Factory

	test "get instance information", %{conn: conn} do
	conn = get(conn, "/api/v1/instance")
	assert result = json_response_and_validate_schema(conn, 200)

	email = Pleroma.Config.get([:instance, :email])
	- thumbnail = Pleroma.Web.base_url() <> Pleroma.Config.get([:instance, :instance_thumbnail])
	- background = Pleroma.Web.base_url() <> Pleroma.Config.get([:instance, :background_image])
	+ thumbnail = Pleroma.Web.Endpoint.url() <> Pleroma.Config.get([:instance, :instance_thumbnail])
	+ background = Pleroma.Web.Endpoint.url() <> Pleroma.Config.get([:instance, :background_image])

	# Note: not checking for "max_toot_chars" since it's optional
	assert %{
	"uri" => _,
	"title" => _,
	"description" => _,
	"version" => _,
	"email" => from_config_email,
	"urls" => %{
	"streaming_api" => _
	},
	"stats" => _,
	"thumbnail" => from_config_thumbnail,
	"languages" => _,
	"registrations" => _,
	"approval_required" => _,
	"poll_limits" => _,
	"upload_limit" => _,
	"avatar_upload_limit" => _,
	"background_upload_limit" => _,
	"banner_upload_limit" => _,
	"background_image" => from_config_background,
	"chat_limit" => _,
	"description_limit" => _
	} = result

	assert result["pleroma"]["metadata"]["account_activation_required"] != nil
	assert result["pleroma"]["metadata"]["features"]
	assert result["pleroma"]["metadata"]["federation"]
	assert result["pleroma"]["metadata"]["fields_limits"]
	assert result["pleroma"]["vapid_public_key"]
	assert result["pleroma"]["stats"]["mau"] == 0

	assert email == from_config_email
	assert thumbnail == from_config_thumbnail
	assert background == from_config_background
	end

	test "get instance stats", %{conn: conn} do
	user = insert(:user, %{local: true})

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.set_activation(user2, false)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})

	Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance")

	assert result = json_response_and_validate_schema(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response_and_validate_schema(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	index 1dd0fa3b8..8e5995933 100644
	--- a/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/search_controller_test.exs
	@@ -1,417 +1,417 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.SearchControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Object
	alias Pleroma.Web
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock
	import Mock

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

	describe ".search2" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v2/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "2hu #private"})}")
	\|> json_response_and_validate_schema(200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == [
	- %{"name" => "private", "url" => "#{Web.base_url()}/tag/private"}
	+ %{"name" => "private", "url" => "#{Web.Endpoint.url()}/tag/private"}
	]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)

	results =
	get(conn, "/api/v2/search?q=天子")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	- %{"name" => "天子", "url" => "#{Web.base_url()}/tag/天子"}
	+ %{"name" => "天子", "url" => "#{Web.Endpoint.url()}/tag/天子"}
	]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	@tag capture_log: true
	test "constructs hashtags from search query", %{conn: conn} do
	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "some text with #explicit #hashtags"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	- %{"name" => "explicit", "url" => "#{Web.base_url()}/tag/explicit"},
	- %{"name" => "hashtags", "url" => "#{Web.base_url()}/tag/hashtags"}
	+ %{"name" => "explicit", "url" => "#{Web.Endpoint.url()}/tag/explicit"},
	+ %{"name" => "hashtags", "url" => "#{Web.Endpoint.url()}/tag/hashtags"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "john doe JOHN DOE"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	- %{"name" => "john", "url" => "#{Web.base_url()}/tag/john"},
	- %{"name" => "doe", "url" => "#{Web.base_url()}/tag/doe"},
	- %{"name" => "JohnDoe", "url" => "#{Web.base_url()}/tag/JohnDoe"}
	+ %{"name" => "john", "url" => "#{Web.Endpoint.url()}/tag/john"},
	+ %{"name" => "doe", "url" => "#{Web.Endpoint.url()}/tag/doe"},
	+ %{"name" => "JohnDoe", "url" => "#{Web.Endpoint.url()}/tag/JohnDoe"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "accident-prone"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	- %{"name" => "accident", "url" => "#{Web.base_url()}/tag/accident"},
	- %{"name" => "prone", "url" => "#{Web.base_url()}/tag/prone"},
	- %{"name" => "AccidentProne", "url" => "#{Web.base_url()}/tag/AccidentProne"}
	+ %{"name" => "accident", "url" => "#{Web.Endpoint.url()}/tag/accident"},
	+ %{"name" => "prone", "url" => "#{Web.Endpoint.url()}/tag/prone"},
	+ %{"name" => "AccidentProne", "url" => "#{Web.Endpoint.url()}/tag/AccidentProne"}
	]

	results =
	conn
	\|> get("/api/v2/search?#{URI.encode_query(%{q: "https://shpposter.club/users/shpuld"})}")
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	- %{"name" => "shpuld", "url" => "#{Web.base_url()}/tag/shpuld"}
	+ %{"name" => "shpuld", "url" => "#{Web.Endpoint.url()}/tag/shpuld"}
	]

	results =
	conn
	\|> get(
	"/api/v2/search?#{
	URI.encode_query(%{
	q:
	"https://www.washingtonpost.com/sports/2020/06/10/" <>
	"nascar-ban-display-confederate-flag-all-events-properties/"
	})
	}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	- %{"name" => "nascar", "url" => "#{Web.base_url()}/tag/nascar"},
	- %{"name" => "ban", "url" => "#{Web.base_url()}/tag/ban"},
	- %{"name" => "display", "url" => "#{Web.base_url()}/tag/display"},
	- %{"name" => "confederate", "url" => "#{Web.base_url()}/tag/confederate"},
	- %{"name" => "flag", "url" => "#{Web.base_url()}/tag/flag"},
	- %{"name" => "all", "url" => "#{Web.base_url()}/tag/all"},
	- %{"name" => "events", "url" => "#{Web.base_url()}/tag/events"},
	- %{"name" => "properties", "url" => "#{Web.base_url()}/tag/properties"},
	+ %{"name" => "nascar", "url" => "#{Web.Endpoint.url()}/tag/nascar"},
	+ %{"name" => "ban", "url" => "#{Web.Endpoint.url()}/tag/ban"},
	+ %{"name" => "display", "url" => "#{Web.Endpoint.url()}/tag/display"},
	+ %{"name" => "confederate", "url" => "#{Web.Endpoint.url()}/tag/confederate"},
	+ %{"name" => "flag", "url" => "#{Web.Endpoint.url()}/tag/flag"},
	+ %{"name" => "all", "url" => "#{Web.Endpoint.url()}/tag/all"},
	+ %{"name" => "events", "url" => "#{Web.Endpoint.url()}/tag/events"},
	+ %{"name" => "properties", "url" => "#{Web.Endpoint.url()}/tag/properties"},
	%{
	"name" => "NascarBanDisplayConfederateFlagAllEventsProperties",
	"url" =>
	- "#{Web.base_url()}/tag/NascarBanDisplayConfederateFlagAllEventsProperties"
	+ "#{Web.Endpoint.url()}/tag/NascarBanDisplayConfederateFlagAllEventsProperties"
	}
	]
	end

	test "supports pagination of hashtags search results", %{conn: conn} do
	results =
	conn
	\|> get(
	"/api/v2/search?#{
	URI.encode_query(%{q: "#some #text #with #hashtags", limit: 2, offset: 1})
	}"
	)
	\|> json_response_and_validate_schema(200)

	assert results["hashtags"] == [
	- %{"name" => "text", "url" => "#{Web.base_url()}/tag/text"},
	- %{"name" => "with", "url" => "#{Web.base_url()}/tag/with"}
	+ %{"name" => "text", "url" => "#{Web.Endpoint.url()}/tag/text"},
	+ %{"name" => "with", "url" => "#{Web.Endpoint.url()}/tag/with"}
	]
	end

	test "excludes a blocked users from search results", %{conn: conn} do
	user = insert(:user)
	user_smith = insert(:user, %{nickname: "Agent", name: "I love 2hu"})
	user_neo = insert(:user, %{nickname: "Agent Neo", name: "Agent"})

	{:ok, act1} = CommonAPI.post(user, %{status: "This is about 2hu private 天子"})
	{:ok, act2} = CommonAPI.post(user_smith, %{status: "Agent Smith"})
	{:ok, act3} = CommonAPI.post(user_neo, %{status: "Agent Smith"})
	Pleroma.User.block(user, user_smith)

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v2/search?q=Agent")
	\|> json_response_and_validate_schema(200)

	status_ids = Enum.map(results["statuses"], fn g -> g["id"] end)

	assert act3.id in status_ids
	refute act2.id in status_ids
	refute act1.id in status_ids
	end
	end

	describe ".account_search" do
	test "account search", %{conn: conn} do
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp")
	\|> json_response_and_validate_schema(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_two.nickname in result_ids
	assert user_three.nickname in result_ids

	results =
	conn
	\|> get("/api/v1/accounts/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_three.nickname in result_ids
	end

	test "returns account if query contains a space", %{conn: conn} do
	insert(:user, %{nickname: "shp@shitposter.club"})

	results =
	conn
	\|> get("/api/v1/accounts/search?q=shp@shitposter.club xxx")
	\|> json_response_and_validate_schema(200)

	assert length(results) == 1
	end
	end

	describe ".search" do
	test "it returns empty result if user or status search return undefined error", %{conn: conn} do
	with_mocks [
	{Pleroma.User, [], [search: fn _q, _o -> raise "Oops" end]},
	{Pleroma.Activity, [], [search: fn _u, _q, _o -> raise "Oops" end]}
	] do
	capture_log(fn ->
	results =
	conn
	\|> get("/api/v1/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	assert results["accounts"] == []
	assert results["statuses"] == []
	end) =~
	"[error] Elixir.Pleroma.Web.MastodonAPI.SearchController search error: %RuntimeError{message: \"Oops\"}"
	end
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

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

	{:ok, _activity} =
	CommonAPI.post(user, %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{status: "This isn't"})

	results =
	conn
	\|> get("/api/v1/search?q=2hu")
	\|> json_response_and_validate_schema(200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == ["2hu"]

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search fetches remote statuses and prefers them over other results", %{conn: conn} do
	old_version = :persistent_term.get({Pleroma.Repo, :postgres_version})
	:persistent_term.put({Pleroma.Repo, :postgres_version}, 10.0)
	on_exit(fn -> :persistent_term.put({Pleroma.Repo, :postgres_version}, old_version) end)

	capture_log(fn ->
	{:ok, %{id: activity_id}} =
	CommonAPI.post(insert(:user), %{
	status: "check out http://mastodon.example.org/@admin/99541947525187367"
	})

	results =
	conn
	\|> get("/api/v1/search?q=http://mastodon.example.org/@admin/99541947525187367")
	\|> json_response_and_validate_schema(200)

	assert [
	%{"url" => "http://mastodon.example.org/@admin/99541947525187367"},
	%{"id" => ^activity_id}
	] = results["statuses"]
	end)
	end

	test "search doesn't show statuses that it shouldn't", %{conn: conn} do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	status: "This is about 2hu, but private",
	visibility: "private"
	})

	capture_log(fn ->
	q = Object.normalize(activity, fetch: false).data["id"]

	results =
	conn
	\|> get("/api/v1/search?q=#{q}")
	\|> json_response_and_validate_schema(200)

	[] = results["statuses"]
	end)
	end

	test "search fetches remote accounts", %{conn: conn} do
	user = insert(:user)

	query = URI.encode_query(%{q: " mike@osada.macgirvin.com ", resolve: true})

	results =
	conn
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read"]))
	\|> get("/api/v1/search?#{query}")
	\|> json_response_and_validate_schema(200)

	[account] = results["accounts"]
	assert account["acct"] == "mike@osada.macgirvin.com"
	end

	test "search doesn't fetch remote accounts if resolve is false", %{conn: conn} do
	results =
	conn
	\|> get("/api/v1/search?q=mike@osada.macgirvin.com&resolve=false")
	\|> json_response_and_validate_schema(200)

	assert [] == results["accounts"]
	end

	test "search with limit and offset", %{conn: conn} do
	user = insert(:user)
	_user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	_user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, _activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
	{:ok, _activity2} = CommonAPI.post(user, %{status: "This is also about 2hu"})

	result =
	conn
	\|> get("/api/v1/search?q=2hu&limit=1")

	assert results = json_response_and_validate_schema(result, 200)
	assert [%{"id" => activity_id1}] = results["statuses"]
	assert [_] = results["accounts"]

	results =
	conn
	\|> get("/api/v1/search?q=2hu&limit=1&offset=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert [] = results["accounts"]

	assert activity_id1 != activity_id2
	end

	test "search returns results only for the given type", %{conn: conn} do
	user = insert(:user)
	_user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, _activity} = CommonAPI.post(user, %{status: "This is about 2hu"})

	assert %{"statuses" => [_activity], "accounts" => [], "hashtags" => []} =
	conn
	\|> get("/api/v1/search?q=2hu&type=statuses")
	\|> json_response_and_validate_schema(200)

	assert %{"statuses" => [], "accounts" => [_user_two], "hashtags" => []} =
	conn
	\|> get("/api/v1/search?q=2hu&type=accounts")
	\|> json_response_and_validate_schema(200)
	end

	test "search uses account_id to filter statuses by the author", %{conn: conn} do
	user = insert(:user, %{nickname: "shp@shitposter.club"})
	user_two = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity1} = CommonAPI.post(user, %{status: "This is about 2hu"})
	{:ok, activity2} = CommonAPI.post(user_two, %{status: "This is also about 2hu"})

	results =
	conn
	\|> get("/api/v1/search?q=2hu&account_id=#{user.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id1}] = results["statuses"]
	assert activity_id1 == activity1.id
	assert [_] = results["accounts"]

	results =
	conn
	\|> get("/api/v1/search?q=2hu&account_id=#{user_two.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => activity_id2}] = results["statuses"]
	assert activity_id2 == activity2.id
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/account_view_test.exs b/test/pleroma/web/mastodon_api/views/account_view_test.exs
	index 5373a17c3..28eb4f1d0 100644
	--- a/test/pleroma/web/mastodon_api/views/account_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/account_view_test.exs
	@@ -1,579 +1,579 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView

	import Pleroma.Factory
	import Tesla.Mock

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

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

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

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

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

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

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

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

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

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

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

	privacy = user.default_scope

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	test_relationship_rendering(user, other_user, expected)
	end

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

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

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

	test_relationship_rendering(user, other_user, expected)
	end

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

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

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

	test_relationship_rendering(user, other_user, expected)
	end

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

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

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

	test_relationship_rendering(user, other_user, expected)
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	user = User.get_cached_by_ap_id(user.ap_id)

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

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

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

	user = User.get_cached_by_ap_id(user.ap_id)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	with media_preview_enabled <- [false, true] do
	clear_config([:media_preview_proxy, :enabled], media_preview_enabled)

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

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

	_ ->
	true
	end)
	\|> assert()
	end
	end
	end
	diff --git a/test/pleroma/web/media_proxy_test.exs b/test/pleroma/web/media_proxy_test.exs
	index 7411d0a7a..254ac3266 100644
	--- a/test/pleroma/web/media_proxy_test.exs
	+++ b/test/pleroma/web/media_proxy_test.exs
	@@ -1,234 +1,234 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxyTest do
	use ExUnit.Case
	use Pleroma.Tests.Helpers

	alias Pleroma.Config
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

	defp decode_result(encoded) do
	[_, "proxy", sig, base64 \| _] = URI.parse(encoded).path \|> String.split("/")
	{:ok, decoded} = MediaProxy.decode_url(sig, base64)
	decoded
	end

	describe "when enabled" do
	setup do: clear_config([:media_proxy, :enabled], true)

	test "ignores invalid url" do
	assert MediaProxy.url(nil) == nil
	assert MediaProxy.url("") == nil
	end

	test "ignores relative url" do
	assert MediaProxy.url("/local") == "/local"
	assert MediaProxy.url("/") == "/"
	end

	test "ignores local url" do
	local_url = Endpoint.url() <> "/hello"
	local_root = Endpoint.url()
	assert MediaProxy.url(local_url) == local_url
	assert MediaProxy.url(local_root) == local_root
	end

	test "encodes and decodes URL" do
	url = "https://pleroma.soykaf.com/static/logo.png"
	encoded = MediaProxy.url(url)

	assert String.starts_with?(
	encoded,
	- Config.get([:media_proxy, :base_url], Pleroma.Web.base_url())
	+ Config.get([:media_proxy, :base_url], Pleroma.Web.Endpoint.url())
	)

	assert String.ends_with?(encoded, "/logo.png")

	assert decode_result(encoded) == url
	end

	test "encodes and decodes URL without a path" do
	url = "https://pleroma.soykaf.com"
	encoded = MediaProxy.url(url)
	assert decode_result(encoded) == url
	end

	test "encodes and decodes URL without an extension" do
	url = "https://pleroma.soykaf.com/path/"
	encoded = MediaProxy.url(url)
	assert String.ends_with?(encoded, "/path")
	assert decode_result(encoded) == url
	end

	test "encodes and decodes URL and ignores query params for the path" do
	url = "https://pleroma.soykaf.com/static/logo.png?93939393939&bunny=true"
	encoded = MediaProxy.url(url)
	assert String.ends_with?(encoded, "/logo.png")
	assert decode_result(encoded) == url
	end

	test "validates signature" do
	encoded = MediaProxy.url("https://pleroma.social")

	clear_config(
	[Endpoint, :secret_key_base],
	"00000000000000000000000000000000000000000000000"
	)

	[_, "proxy", sig, base64 \| _] = URI.parse(encoded).path \|> String.split("/")
	assert MediaProxy.decode_url(sig, base64) == {:error, :invalid_signature}
	end

	def test_verify_request_path_and_url(request_path, url, expected_result) do
	assert MediaProxy.verify_request_path_and_url(request_path, url) == expected_result

	assert MediaProxy.verify_request_path_and_url(
	%Plug.Conn{
	params: %{"filename" => Path.basename(request_path)},
	request_path: request_path
	},
	url
	) == expected_result
	end

	test "if first arg of `verify_request_path_and_url/2` is a Plug.Conn without \"filename\" " <>
	"parameter, `verify_request_path_and_url/2` returns :ok " do
	assert MediaProxy.verify_request_path_and_url(
	%Plug.Conn{params: %{}, request_path: "/some/path"},
	"https://instance.com/file.jpg"
	) == :ok

	assert MediaProxy.verify_request_path_and_url(
	%Plug.Conn{params: %{}, request_path: "/path/to/file.jpg"},
	"https://instance.com/file.jpg"
	) == :ok
	end

	test "`verify_request_path_and_url/2` preserves the encoded or decoded path" do
	test_verify_request_path_and_url(
	"/Hello world.jpg",
	"http://pleroma.social/Hello world.jpg",
	:ok
	)

	test_verify_request_path_and_url(
	"/Hello%20world.jpg",
	"http://pleroma.social/Hello%20world.jpg",
	:ok
	)

	test_verify_request_path_and_url(
	"/my%2Flong%2Furl%2F2019%2F07%2FS.jpg",
	"http://pleroma.social/my%2Flong%2Furl%2F2019%2F07%2FS.jpg",
	:ok
	)

	test_verify_request_path_and_url(
	# Note: `conn.request_path` returns encoded url
	"/ANALYSE-DAI-_-LE-STABLECOIN-100-D%C3%89CENTRALIS%C3%89-BQ.jpg",
	"https://mydomain.com/uploads/2019/07/ANALYSE-DAI-_-LE-STABLECOIN-100-DÉCENTRALISÉ-BQ.jpg",
	:ok
	)

	test_verify_request_path_and_url(
	"/my%2Flong%2Furl%2F2019%2F07%2FS",
	"http://pleroma.social/my%2Flong%2Furl%2F2019%2F07%2FS.jpg",
	{:wrong_filename, "my%2Flong%2Furl%2F2019%2F07%2FS.jpg"}
	)
	end

	test "uses the configured base_url" do
	base_url = "https://cache.pleroma.social"
	clear_config([:media_proxy, :base_url], base_url)

	url = "https://pleroma.soykaf.com/static/logo.png"
	encoded = MediaProxy.url(url)

	assert String.starts_with?(encoded, base_url)
	end

	# Some sites expect ASCII encoded characters in the URL to be preserved even if
	# unnecessary.
	# Issues: https://git.pleroma.social/pleroma/pleroma/issues/580
	# https://git.pleroma.social/pleroma/pleroma/issues/1055
	test "preserve ASCII encoding" do
	url =
	"https://pleroma.com/%20/%21/%22/%23/%24/%25/%26/%27/%28/%29/%2A/%2B/%2C/%2D/%2E/%2F/%30/%31/%32/%33/%34/%35/%36/%37/%38/%39/%3A/%3B/%3C/%3D/%3E/%3F/%40/%41/%42/%43/%44/%45/%46/%47/%48/%49/%4A/%4B/%4C/%4D/%4E/%4F/%50/%51/%52/%53/%54/%55/%56/%57/%58/%59/%5A/%5B/%5C/%5D/%5E/%5F/%60/%61/%62/%63/%64/%65/%66/%67/%68/%69/%6A/%6B/%6C/%6D/%6E/%6F/%70/%71/%72/%73/%74/%75/%76/%77/%78/%79/%7A/%7B/%7C/%7D/%7E/%7F/%80/%81/%82/%83/%84/%85/%86/%87/%88/%89/%8A/%8B/%8C/%8D/%8E/%8F/%90/%91/%92/%93/%94/%95/%96/%97/%98/%99/%9A/%9B/%9C/%9D/%9E/%9F/%C2%A0/%A1/%A2/%A3/%A4/%A5/%A6/%A7/%A8/%A9/%AA/%AB/%AC/%C2%AD/%AE/%AF/%B0/%B1/%B2/%B3/%B4/%B5/%B6/%B7/%B8/%B9/%BA/%BB/%BC/%BD/%BE/%BF/%C0/%C1/%C2/%C3/%C4/%C5/%C6/%C7/%C8/%C9/%CA/%CB/%CC/%CD/%CE/%CF/%D0/%D1/%D2/%D3/%D4/%D5/%D6/%D7/%D8/%D9/%DA/%DB/%DC/%DD/%DE/%DF/%E0/%E1/%E2/%E3/%E4/%E5/%E6/%E7/%E8/%E9/%EA/%EB/%EC/%ED/%EE/%EF/%F0/%F1/%F2/%F3/%F4/%F5/%F6/%F7/%F8/%F9/%FA/%FB/%FC/%FD/%FE/%FF"

	encoded = MediaProxy.url(url)
	assert decode_result(encoded) == url
	end

	# This includes unsafe/reserved characters which are not interpreted as part of the URL
	# and would otherwise have to be ASCII encoded. It is our role to ensure the proxied URL
	# is unmodified, so we are testing these characters anyway.
	test "preserve non-unicode characters per RFC3986" do
	url =
	"https://pleroma.com/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890-._~:/?#[]@!$&'()*+,;=\|^`{}"

	encoded = MediaProxy.url(url)
	assert decode_result(encoded) == url
	end

	test "preserve unicode characters" do
	url = "https://ko.wikipedia.org/wiki/위키백과:대문"

	encoded = MediaProxy.url(url)
	assert decode_result(encoded) == url
	end
	end

	describe "when disabled" do
	setup do: clear_config([:media_proxy, :enabled], false)

	test "does not encode remote urls" do
	assert MediaProxy.url("https://google.fr") == "https://google.fr"
	end
	end

	describe "whitelist" do
	setup do: clear_config([:media_proxy, :enabled], true)

	test "mediaproxy whitelist" do
	clear_config([:media_proxy, :whitelist], ["https://google.com", "https://feld.me"])
	url = "https://feld.me/foo.png"

	unencoded = MediaProxy.url(url)
	assert unencoded == url
	end

	# TODO: delete after removing support bare domains for media proxy whitelist
	test "mediaproxy whitelist bare domains whitelist (deprecated)" do
	clear_config([:media_proxy, :whitelist], ["google.com", "feld.me"])
	url = "https://feld.me/foo.png"

	unencoded = MediaProxy.url(url)
	assert unencoded == url
	end

	test "does not change whitelisted urls" do
	clear_config([:media_proxy, :whitelist], ["mycdn.akamai.com"])
	clear_config([:media_proxy, :base_url], "https://cache.pleroma.social")

	media_url = "https://mycdn.akamai.com"

	url = "#{media_url}/static/logo.png"
	encoded = MediaProxy.url(url)

	assert String.starts_with?(encoded, media_url)
	end

	test "ensure Pleroma.Upload base_url is always whitelisted" do
	media_url = "https://media.pleroma.social"
	clear_config([Pleroma.Upload, :base_url], media_url)

	url = "#{media_url}/static/logo.png"
	encoded = MediaProxy.url(url)

	assert String.starts_with?(encoded, media_url)
	end
	end
	end
	diff --git a/test/pleroma/web/o_status/o_status_controller_test.exs b/test/pleroma/web/o_status/o_status_controller_test.exs
	index 2038f4ddd..81d669837 100644
	--- a/test/pleroma/web/o_status/o_status_controller_test.exs
	+++ b/test/pleroma/web/o_status/o_status_controller_test.exs
	@@ -1,346 +1,346 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.OStatusControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint

	require Pleroma.Constants

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

	setup do: clear_config([:static_fe, :enabled], false)

	describe "Mastodon compatibility routes" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")

	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	{:ok, activity, _} =
	%{
	"id" => object.data["id"] <> "/activity",
	"type" => "Create",
	"object" => object.data["id"],
	"actor" => object.data["actor"],
	"to" => object.data["to"]
	}
	\|> ActivityPub.persist(local: true)

	%{conn: conn, activity: activity}
	end

	test "redirects to /notice/:id for html format", %{conn: conn, activity: activity} do
	conn = get(conn, "/users/raymoo/statuses/999999999")
	assert redirected_to(conn) == "/notice/#{activity.id}"
	end

	test "redirects to /notice/:id for html format for activity", %{
	conn: conn,
	activity: activity
	} do
	conn = get(conn, "/users/raymoo/statuses/999999999/activity")
	assert redirected_to(conn) == "/notice/#{activity.id}"
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "GET /objects/:uuid (text/html)" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	%{conn: conn}
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))
	url = "/objects/#{uuid}"

	conn = get(conn, url)
	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "404s on private objects", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	object = Object.normalize(note_activity, fetch: false)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))

	conn
	\|> get("/objects/#{uuid}")
	\|> response(404)
	end

	test "404s on non-existing objects", %{conn: conn} do
	conn
	\|> get("/objects/123")
	\|> response(404)
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "GET /activities/:uuid (text/html)" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	%{conn: conn}
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn = get(conn, "/activities/#{uuid}")
	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "404s on private activities", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn
	\|> get("/activities/#{uuid}")
	\|> response(404)
	end

	test "404s on nonexistent activities", %{conn: conn} do
	conn
	\|> get("/activities/123")
	\|> response(404)
	end
	end

	describe "GET notice/2" do
	test "redirects to a proper object URL when json requested and the object is local", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	expected_redirect_url = Object.normalize(note_activity, fetch: false).data["id"]

	redirect_url =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> redirected_to()

	assert redirect_url == expected_redirect_url
	end

	test "redirects to a proper object URL when json requested and the object is remote", %{
	conn: conn
	} do
	note_activity = insert(:note_activity, local: false)
	expected_redirect_url = Object.normalize(note_activity, fetch: false).data["id"]

	redirect_url =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> redirected_to()

	assert redirect_url == expected_redirect_url
	end

	test "500s when actor not found", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	User.invalidate_cache(user)
	Pleroma.Repo.delete(user)

	conn =
	conn
	\|> get("/notice/#{note_activity.id}")

	assert response(conn, 500) == ~S({"error":"Something went wrong"})
	end

	test "render html for redirect for html format", %{conn: conn} do
	note_activity = insert(:note_activity)

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}")
	\|> response(200)

	assert resp =~
	- "<meta content=\"#{Pleroma.Web.base_url()}/notice/#{note_activity.id}\" property=\"og:url\">"
	+ "<meta content=\"#{Pleroma.Web.Endpoint.url()}/notice/#{note_activity.id}\" property=\"og:url\">"

	user = insert(:user)

	{:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)

	assert like_activity.data["type"] == "Like"

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{like_activity.id}")
	\|> response(200)

	assert resp =~ "<!--server-generated-meta-->"
	end

	test "404s a private notice", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "404s a non-existing notice", %{conn: conn} do
	url = "/notice/123"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "does not require authentication on non-federating instances", %{
	conn: conn
	} do
	clear_config([:instance, :federating], false)
	note_activity = insert(:note_activity)

	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}")
	\|> response(200)
	end
	end

	describe "GET /notice/:id/embed_player" do
	setup do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity, fetch: false)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	%{note_activity: note_activity}
	end

	test "renders embed player", %{conn: conn, note_activity: note_activity} do
	conn = get(conn, "/notice/#{note_activity.id}/embed_player")

	assert Plug.Conn.get_resp_header(conn, "x-frame-options") == ["ALLOW"]

	assert Plug.Conn.get_resp_header(
	conn,
	"content-security-policy"
	) == [
	"default-src 'none';style-src 'self' 'unsafe-inline';img-src 'self' data: https:; media-src 'self' https:;"
	]

	assert response(conn, 200) =~
	"<video controls loop><source src=\"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4\" type=\"video/mp4\">Your browser does not support video/mp4 playback.</video>"
	end

	test "404s when activity isn't create", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"type" => "Like"})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when activity is direct message", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"directMessage" => true})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment is empty", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity, fetch: false)
	object_data = Map.put(object.data, "attachment", [])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment isn't audio or video", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity, fetch: false)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" => "https://peertube.moe/static/webseed/480.jpg",
	"mediaType" => "image/jpg",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "does not require authentication on non-federating instances", %{
	conn: conn,
	note_activity: note_activity
	} do
	clear_config([:instance, :federating], false)

	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(200)
	end
	end
	end
	diff --git a/test/pleroma/web/web_finger/web_finger_controller_test.exs b/test/pleroma/web/web_finger/web_finger_controller_test.exs
	index 7059850bd..2421c5800 100644
	--- a/test/pleroma/web/web_finger/web_finger_controller_test.exs
	+++ b/test/pleroma/web/web_finger/web_finger_controller_test.exs
	@@ -1,110 +1,110 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFinger.WebFingerControllerTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Tesla.Mock

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

	setup_all do: clear_config([:instance, :federating], true)

	test "GET host-meta" do
	response =
	build_conn()
	\|> get("/.well-known/host-meta")

	assert response.status == 200

	assert response.resp_body ==
	~s(<?xml version="1.0" encoding="UTF-8"?><XRD xmlns="http://docs.oasis-open.org/ns/xri/xrd-1.0"><Link rel="lrdd" template="#{
	- Pleroma.Web.base_url()
	+ Pleroma.Web.Endpoint.url()
	}/.well-known/webfinger?resource={uri}" type="application/xrd+xml" /></XRD>)
	end

	test "Webfinger JRD" do
	user =
	insert(:user,
	ap_id: "https://hyrule.world/users/zelda",
	also_known_as: ["https://mushroom.kingdom/users/toad"]
	)

	response =
	build_conn()
	\|> put_req_header("accept", "application/jrd+json")
	\|> get("/.well-known/webfinger?resource=acct:#{user.nickname}@localhost")
	\|> json_response(200)

	assert response["subject"] == "acct:#{user.nickname}@localhost"

	assert response["aliases"] == [
	"https://hyrule.world/users/zelda",
	"https://mushroom.kingdom/users/toad"
	]
	end

	test "it returns 404 when user isn't found (JSON)" do
	result =
	build_conn()
	\|> put_req_header("accept", "application/jrd+json")
	\|> get("/.well-known/webfinger?resource=acct:jimm@localhost")
	\|> json_response(404)

	assert result == "Couldn't find user"
	end

	test "Webfinger XML" do
	user =
	insert(:user,
	ap_id: "https://hyrule.world/users/zelda",
	also_known_as: ["https://mushroom.kingdom/users/toad"]
	)

	response =
	build_conn()
	\|> put_req_header("accept", "application/xrd+xml")
	\|> get("/.well-known/webfinger?resource=acct:#{user.nickname}@localhost")
	\|> response(200)

	assert response =~ "<Alias>https://hyrule.world/users/zelda</Alias>"
	assert response =~ "<Alias>https://mushroom.kingdom/users/toad</Alias>"
	end

	test "it returns 404 when user isn't found (XML)" do
	result =
	build_conn()
	\|> put_req_header("accept", "application/xrd+xml")
	\|> get("/.well-known/webfinger?resource=acct:jimm@localhost")
	\|> response(404)

	assert result == "Couldn't find user"
	end

	test "Sends a 404 when invalid format" do
	user = insert(:user)

	assert capture_log(fn ->
	assert_raise Phoenix.NotAcceptableError, fn ->
	build_conn()
	\|> put_req_header("accept", "text/html")
	\|> get("/.well-known/webfinger?resource=acct:#{user.nickname}@localhost")
	end
	end) =~ "no supported media type in accept header"
	end

	test "Sends a 400 when resource param is missing" do
	response =
	build_conn()
	\|> put_req_header("accept", "application/xrd+xml,application/jrd+json")
	\|> get("/.well-known/webfinger")

	assert response(response, 400)
	end
	end
	diff --git a/test/pleroma/web/web_finger_test.exs b/test/pleroma/web/web_finger_test.exs
	index 84477d5a1..7b90c5457 100644
	--- a/test/pleroma/web/web_finger_test.exs
	+++ b/test/pleroma/web/web_finger_test.exs
	@@ -1,117 +1,117 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFingerTest do
	use Pleroma.DataCase, async: true
	alias Pleroma.Web.WebFinger
	import Pleroma.Factory
	import Tesla.Mock

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

	describe "host meta" do
	test "returns a link to the xml lrdd" do
	host_info = WebFinger.host_meta()

	- assert String.contains?(host_info, Pleroma.Web.base_url())
	+ assert String.contains?(host_info, Pleroma.Web.Endpoint.url())
	end
	end

	describe "incoming webfinger request" do
	test "works for fqns" do
	user = insert(:user)

	{:ok, result} =
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}", "XML")

	assert is_binary(result)
	end

	test "works for ap_ids" do
	user = insert(:user)

	{:ok, result} = WebFinger.webfinger(user.ap_id, "XML")
	assert is_binary(result)
	end
	end

	describe "fingering" do
	test "returns error for nonsensical input" do
	assert {:error, _} = WebFinger.finger("bliblablu")
	assert {:error, _} = WebFinger.finger("pleroma.social")
	end

	test "returns error when fails parse xml or json" do
	user = "invalid_content@social.heldscal.la"
	assert {:error, %Jason.DecodeError{}} = WebFinger.finger(user)
	end

	test "returns the ActivityPub actor URI for an ActivityPub user" do
	user = "framasoft@framatube.org"

	{:ok, _data} = WebFinger.finger(user)
	end

	test "returns the ActivityPub actor URI and subscribe address for an ActivityPub user with the ld+json mimetype" do
	user = "kaniini@gerzilla.de"

	{:ok, data} = WebFinger.finger(user)

	assert data["ap_id"] == "https://gerzilla.de/channel/kaniini"
	assert data["subscribe_address"] == "https://gerzilla.de/follow?f=&url={uri}"
	end

	test "it work for AP-only user" do
	user = "kpherox@mstdn.jp"

	{:ok, data} = WebFinger.finger(user)

	assert data["magic_key"] == nil
	assert data["salmon"] == nil

	assert data["topic"] == nil
	assert data["subject"] == "acct:kPherox@mstdn.jp"
	assert data["ap_id"] == "https://mstdn.jp/users/kPherox"
	assert data["subscribe_address"] == "https://mstdn.jp/authorize_interaction?acct={uri}"
	end

	test "it works for friendica" do
	user = "lain@squeet.me"

	{:ok, _data} = WebFinger.finger(user)
	end

	test "it gets the xrd endpoint" do
	{:ok, template} = WebFinger.find_lrdd_template("social.heldscal.la")

	assert template == "https://social.heldscal.la/.well-known/webfinger?resource={uri}"
	end

	test "it gets the xrd endpoint for hubzilla" do
	{:ok, template} = WebFinger.find_lrdd_template("macgirvin.com")

	assert template == "https://macgirvin.com/xrd/?uri={uri}"
	end

	test "it gets the xrd endpoint for statusnet" do
	{:ok, template} = WebFinger.find_lrdd_template("status.alpicola.com")

	assert template == "http://status.alpicola.com/main/xrd?uri={uri}"
	end

	test "it works with idna domains as nickname" do
	nickname = "lain@" <> to_string(:idna.encode("zetsubou.みんな"))

	{:ok, _data} = WebFinger.finger(nickname)
	end

	test "it works with idna domains as link" do
	ap_id = "https://" <> to_string(:idna.encode("zetsubou.みんな")) <> "/users/lain"
	{:ok, _data} = WebFinger.finger(ap_id)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 3:24 AM (17 h, 18 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802327
Default Alt Text: (501 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions