No OneTemporary
Actions

Size

109 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/dialyzer4.skip b/changelog.d/dialyzer4.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/lib/mix/tasks/pleroma/emoji.ex b/lib/mix/tasks/pleroma/emoji.ex
	index 537f0715e..8b9c921c8 100644
	--- a/lib/mix/tasks/pleroma/emoji.ex
	+++ b/lib/mix/tasks/pleroma/emoji.ex
	@@ -1,275 +1,275 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Emoji do
	use Mix.Task
	import Mix.Pleroma

	@shortdoc "Manages emoji packs"
	@moduledoc File.read!("docs/administration/CLI_tasks/emoji.md")

	def run(["ls-packs" \| args]) do
	start_pleroma()

	{options, [], []} = parse_global_opts(args)

	url_or_path = options[:manifest] \|\| default_manifest()
	manifest = fetch_and_decode!(url_or_path)

	Enum.each(manifest, fn {name, info} ->
	to_print = [
	{"Name", name},
	{"Homepage", info["homepage"]},
	{"Description", info["description"]},
	{"License", info["license"]},
	{"Source", info["src"]}
	]

	for {param, value} <- to_print do
	IO.puts(IO.ANSI.format([:bright, param, :normal, ": ", value]))
	end

	# A newline
	IO.puts("")
	end)
	end

	def run(["get-packs" \| args]) do
	start_pleroma()

	{options, pack_names, []} = parse_global_opts(args)

	url_or_path = options[:manifest] \|\| default_manifest()

	manifest = fetch_and_decode!(url_or_path)

	for pack_name <- pack_names do
	if Map.has_key?(manifest, pack_name) do
	pack = manifest[pack_name]
	src = pack["src"]

	IO.puts(
	IO.ANSI.format([
	"Downloading ",
	:bright,
	pack_name,
	:normal,
	" from ",
	:underline,
	src
	])
	)

	{:ok, binary_archive} = fetch(src)
	archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()

	sha_status_text = ["SHA256 of ", :bright, pack_name, :normal, " source file is ", :bright]

	if archive_sha == String.upcase(pack["src_sha256"]) do
	IO.puts(IO.ANSI.format(sha_status_text ++ [:green, "OK"]))
	else
	IO.puts(IO.ANSI.format(sha_status_text ++ [:red, "BAD"]))

	raise "Bad SHA256 for #{pack_name}"
	end

	# The location specified in files should be in the same directory
	files_loc =
	url_or_path
	\|> Path.dirname()
	\|> Path.join(pack["files"])

	IO.puts(
	IO.ANSI.format([
	"Fetching the file list for ",
	:bright,
	pack_name,
	:normal,
	" from ",
	:underline,
	files_loc
	])
	)

	files = fetch_and_decode!(files_loc)

	IO.puts(IO.ANSI.format(["Unpacking ", :bright, pack_name]))

	pack_path =
	Path.join([
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji",
	pack_name
	])

	files_to_unzip =
	Enum.map(
	files,
	fn {_, f} -> to_charlist(f) end
	)

	{:ok, _} =
	:zip.unzip(binary_archive,
	- cwd: pack_path,
	+ cwd: String.to_charlist(pack_path),
	file_list: files_to_unzip
	)

	IO.puts(IO.ANSI.format(["Writing pack.json for ", :bright, pack_name]))

	pack_json = %{
	pack: %{
	"license" => pack["license"],
	"homepage" => pack["homepage"],
	"description" => pack["description"],
	"fallback-src" => pack["src"],
	"fallback-src-sha256" => pack["src_sha256"],
	"share-files" => true
	},
	files: files
	}

	File.write!(Path.join(pack_path, "pack.json"), Jason.encode!(pack_json, pretty: true))
	else
	IO.puts(IO.ANSI.format([:bright, :red, "No pack named \"#{pack_name}\" found"]))
	end
	end
	end

	def run(["gen-pack" \| args]) do
	start_pleroma()

	{opts, [src], []} =
	OptionParser.parse(
	args,
	strict: [
	name: :string,
	license: :string,
	homepage: :string,
	description: :string,
	files: :string,
	extensions: :string
	]
	)

	proposed_name = Path.basename(src) \|> Path.rootname()
	name = get_option(opts, :name, "Pack name:", proposed_name)
	license = get_option(opts, :license, "License:")
	homepage = get_option(opts, :homepage, "Homepage:")
	description = get_option(opts, :description, "Description:")

	proposed_files_name = "#{name}_files.json"
	files_name = get_option(opts, :files, "Save file list to:", proposed_files_name)

	default_exts = [".png", ".gif"]

	custom_exts =
	get_option(
	opts,
	:extensions,
	"Emoji file extensions (separated with spaces):",
	Enum.join(default_exts, " ")
	)
	\|> String.split(" ", trim: true)

	exts =
	if MapSet.equal?(MapSet.new(default_exts), MapSet.new(custom_exts)) do
	default_exts
	else
	custom_exts
	end

	IO.puts("Using #{Enum.join(exts, " ")} extensions")

	IO.puts("Downloading the pack and generating SHA256")

	{:ok, %{body: binary_archive}} = Pleroma.HTTP.get(src)
	archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()

	IO.puts("SHA256 is #{archive_sha}")

	pack_json = %{
	name => %{
	license: license,
	homepage: homepage,
	description: description,
	src: src,
	src_sha256: archive_sha,
	files: files_name
	}
	}

	tmp_pack_dir = Path.join(System.tmp_dir!(), "emoji-pack-#{name}")

	{:ok, _} = :zip.unzip(binary_archive, cwd: String.to_charlist(tmp_pack_dir))

	emoji_map = Pleroma.Emoji.Loader.make_shortcode_to_file_map(tmp_pack_dir, exts)

	File.write!(files_name, Jason.encode!(emoji_map, pretty: true))

	IO.puts("""

	#{files_name} has been created and contains the list of all found emojis in the pack.
	Please review the files in the pack and remove those not needed.
	""")

	pack_file = "#{name}.json"

	if File.exists?(pack_file) do
	existing_data = File.read!(pack_file) \|> Jason.decode!()

	File.write!(
	pack_file,
	Jason.encode!(
	Map.merge(
	existing_data,
	pack_json
	),
	pretty: true
	)
	)

	IO.puts("#{pack_file} has been updated with the #{name} pack")
	else
	File.write!(pack_file, Jason.encode!(pack_json, pretty: true))

	IO.puts("#{pack_file} has been created with the #{name} pack")
	end
	end

	def run(["reload"]) do
	start_pleroma()
	Pleroma.Emoji.reload()
	IO.puts("Emoji packs have been reloaded.")
	end

	defp fetch_and_decode!(from) do
	with {:ok, json} <- fetch(from) do
	Jason.decode!(json)
	else
	{:error, error} -> raise "#{from} cannot be fetched. Error: #{error} occur."
	end
	end

	defp fetch("http" <> _ = from) do
	with {:ok, %{body: body}} <- Pleroma.HTTP.get(from) do
	{:ok, body}
	end
	end

	defp fetch(path), do: File.read(path)

	defp parse_global_opts(args) do
	OptionParser.parse(
	args,
	strict: [
	manifest: :string
	],
	aliases: [
	m: :manifest
	]
	)
	end

	defp default_manifest, do: Pleroma.Config.get!([:emoji, :default_manifest])
	end
	diff --git a/lib/pleroma/config/deprecation_warnings.ex b/lib/pleroma/config/deprecation_warnings.ex
	index a77923264..58d164dc7 100644
	--- a/lib/pleroma/config/deprecation_warnings.ex
	+++ b/lib/pleroma/config/deprecation_warnings.ex
	@@ -1,418 +1,418 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.DeprecationWarnings do
	alias Pleroma.Config

	require Logger
	alias Pleroma.Config

	@type config_namespace() :: atom() \| [atom()]
	@type config_map() :: {config_namespace(), config_namespace(), String.t()}

	@mrf_config_map [
	{[:instance, :rewrite_policy], [:mrf, :policies],
	"\n* `config :pleroma, :instance, rewrite_policy` is now `config :pleroma, :mrf, policies`"},
	{[:instance, :mrf_transparency], [:mrf, :transparency],
	"\n* `config :pleroma, :instance, mrf_transparency` is now `config :pleroma, :mrf, transparency`"},
	{[:instance, :mrf_transparency_exclusions], [:mrf, :transparency_exclusions],
	"\n* `config :pleroma, :instance, mrf_transparency_exclusions` is now `config :pleroma, :mrf, transparency_exclusions`"}
	]

	def check_exiftool_filter do
	filters = Config.get([Pleroma.Upload]) \|> Keyword.get(:filters, [])

	if Pleroma.Upload.Filter.Exiftool in filters do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using Exiftool as a filter instead of Exiftool.StripLocation. This should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, Pleroma.Upload,
	filters: [Pleroma.Upload.Filter.Exiftool]
	```

	Is now


	```
	config :pleroma, Pleroma.Upload,
	filters: [Pleroma.Upload.Filter.Exiftool.StripLocation]
	```
	""")

	new_config =
	filters
	\|> Enum.map(fn
	Pleroma.Upload.Filter.Exiftool -> Pleroma.Upload.Filter.Exiftool.StripLocation
	filter -> filter
	end)

	Config.put([Pleroma.Upload, :filters], new_config)

	:error
	else
	:ok
	end
	end

	def check_simple_policy_tuples do
	has_strings =
	Config.get([:mrf_simple])
	\|> Enum.any?(fn {_, v} -> Enum.any?(v, &is_binary/1) end)

	if has_strings do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the SimplePolicy configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :mrf_simple,
	media_removal: ["instance.tld"],
	media_nsfw: ["instance.tld"],
	federated_timeline_removal: ["instance.tld"],
	report_removal: ["instance.tld"],
	reject: ["instance.tld"],
	followers_only: ["instance.tld"],
	accept: ["instance.tld"],
	avatar_removal: ["instance.tld"],
	banner_removal: ["instance.tld"],
	reject_deletes: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :mrf_simple,
	media_removal: [{"instance.tld", "Reason for media removal"}],
	media_nsfw: [{"instance.tld", "Reason for media nsfw"}],
	federated_timeline_removal: [{"instance.tld", "Reason for federated timeline removal"}],
	report_removal: [{"instance.tld", "Reason for report removal"}],
	reject: [{"instance.tld", "Reason for reject"}],
	followers_only: [{"instance.tld", "Reason for followers only"}],
	accept: [{"instance.tld", "Reason for accept"}],
	avatar_removal: [{"instance.tld", "Reason for avatar removal"}],
	banner_removal: [{"instance.tld", "Reason for banner removal"}],
	reject_deletes: [{"instance.tld", "Reason for reject deletes"}]
	```
	""")

	new_config =
	Config.get([:mrf_simple])
	\|> Enum.map(fn {k, v} ->
	{k,
	Enum.map(v, fn
	{instance, reason} -> {instance, reason}
	instance -> {instance, ""}
	end)}
	end)

	Config.put([:mrf_simple], new_config)

	:error
	else
	:ok
	end
	end

	def check_quarantined_instances_tuples do
	has_strings = Config.get([:instance, :quarantined_instances]) \|> Enum.any?(&is_binary/1)

	if has_strings do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the quarantined_instances configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :instance,
	quarantined_instances: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :instance,
	quarantined_instances: [{"instance.tld", "Reason for quarantine"}]
	```
	""")

	new_config =
	Config.get([:instance, :quarantined_instances])
	\|> Enum.map(fn
	{instance, reason} -> {instance, reason}
	instance -> {instance, ""}
	end)

	Config.put([:instance, :quarantined_instances], new_config)

	:error
	else
	:ok
	end
	end

	def check_transparency_exclusions_tuples do
	has_strings = Config.get([:mrf, :transparency_exclusions]) \|> Enum.any?(&is_binary/1)

	if has_strings do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the transparency_exclusions configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :mrf,
	transparency_exclusions: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :mrf,
	transparency_exclusions: [{"instance.tld", "Reason to exclude transparency"}]
	```
	""")

	new_config =
	Config.get([:mrf, :transparency_exclusions])
	\|> Enum.map(fn
	{instance, reason} -> {instance, reason}
	instance -> {instance, ""}
	end)

	Config.put([:mrf, :transparency_exclusions], new_config)

	:error
	else
	:ok
	end
	end

	def check_hellthread_threshold do
	if Config.get([:mrf_hellthread, :threshold]) do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	You are using the old configuration mechanism for the hellthread filter. Please check config.md.
	""")

	:error
	else
	:ok
	end
	end

	def warn do
	[
	check_hellthread_threshold(),
	check_old_mrf_config(),
	check_media_proxy_whitelist_config(),
	check_welcome_message_config(),
	check_gun_pool_options(),
	check_activity_expiration_config(),
	check_remote_ip_plug_name(),
	check_uploaders_s3_public_endpoint(),
	check_old_chat_shoutbox(),
	check_quarantined_instances_tuples(),
	check_transparency_exclusions_tuples(),
	check_simple_policy_tuples(),
	check_exiftool_filter()
	]
	\|> Enum.reduce(:ok, fn
	:ok, :ok -> :ok
	_, _ -> :error
	end)
	end

	def check_welcome_message_config do
	instance_config = Pleroma.Config.get([:instance])

	use_old_config =
	Keyword.has_key?(instance_config, :welcome_user_nickname) or
	Keyword.has_key?(instance_config, :welcome_message)

	if use_old_config do
	Logger.error("""
	!!!DEPRECATION WARNING!!!
	Your config is using the old namespace for Welcome messages configuration. You need to convert to the new namespace. e.g.,
	\n* `config :pleroma, :instance, welcome_user_nickname` and `config :pleroma, :instance, welcome_message` are now equal to:
	\n* `config :pleroma, :welcome, direct_message: [enabled: true, sender_nickname: "NICKNAME", message: "Your welcome message"]`"
	""")

	:error
	else
	:ok
	end
	end

	def check_old_mrf_config do
	warning_preface = """
	!!!DEPRECATION WARNING!!!
	Your config is using old namespaces for MRF configuration. They should work for now, but you are advised to change to new namespaces to prevent possible issues later:
	"""

	move_namespace_and_warn(@mrf_config_map, warning_preface)
	end

	- @spec move_namespace_and_warn([config_map()], String.t()) :: :ok \| nil
	+ @spec move_namespace_and_warn([config_map()], String.t()) :: :ok \| :error
	def move_namespace_and_warn(config_map, warning_preface) do
	warning =
	Enum.reduce(config_map, "", fn
	{old, new, err_msg}, acc ->
	old_config = Config.get(old)

	if old_config do
	Config.put(new, old_config)
	acc <> err_msg
	else
	acc
	end
	end)

	if warning == "" do
	:ok
	else
	Logger.warning(warning_preface <> warning)
	:error
	end
	end

	- @spec check_media_proxy_whitelist_config() :: :ok \| nil
	+ @spec check_media_proxy_whitelist_config() :: :ok \| :error
	def check_media_proxy_whitelist_config do
	whitelist = Config.get([:media_proxy, :whitelist])

	if Enum.any?(whitelist, &(not String.starts_with?(&1, "http"))) do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using old format (only domain) for MediaProxy whitelist option. Setting should work for now, but you are advised to change format to scheme with port to prevent possible issues later.
	""")

	:error
	else
	:ok
	end
	end

	def check_gun_pool_options do
	pool_config = Config.get(:connections_pool)

	if timeout = pool_config[:await_up_timeout] do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using old setting `config :pleroma, :connections_pool, await_up_timeout`. Please change to `config :pleroma, :connections_pool, connect_timeout` to ensure compatibility with future releases.
	""")

	Config.put(:connections_pool, Keyword.put_new(pool_config, :connect_timeout, timeout))
	end

	pools_configs = Config.get(:pools)

	warning_preface = """
	!!!DEPRECATION WARNING!!!
	Your config is using old setting name `timeout` instead of `recv_timeout` in pool settings. The setting will not take effect until updated.
	"""

	updated_config =
	Enum.reduce(pools_configs, [], fn {pool_name, config}, acc ->
	if timeout = config[:timeout] do
	Keyword.put(acc, pool_name, Keyword.put_new(config, :recv_timeout, timeout))
	else
	acc
	end
	end)

	if updated_config != [] do
	pool_warnings =
	updated_config
	\|> Keyword.keys()
	\|> Enum.map(fn pool_name ->
	"\n* `:timeout` options in #{pool_name} pool is now `:recv_timeout`"
	end)

	Logger.warning(Enum.join([warning_preface \| pool_warnings]))

	Config.put(:pools, updated_config)
	:error
	else
	:ok
	end
	end

	- @spec check_activity_expiration_config() :: :ok \| nil
	+ @spec check_activity_expiration_config() :: :ok \| :error
	def check_activity_expiration_config do
	warning_preface = """
	!!!DEPRECATION WARNING!!!
	Your config is using old namespace for activity expiration configuration. Setting should work for now, but you are advised to change to new namespace to prevent possible issues later:
	"""

	move_namespace_and_warn(
	[
	{Pleroma.ActivityExpiration, Pleroma.Workers.PurgeExpiredActivity,
	"\n* `config :pleroma, Pleroma.ActivityExpiration` is now `config :pleroma, Pleroma.Workers.PurgeExpiredActivity`"}
	],
	warning_preface
	)
	end

	- @spec check_remote_ip_plug_name() :: :ok \| nil
	+ @spec check_remote_ip_plug_name() :: :ok \| :error
	def check_remote_ip_plug_name do
	warning_preface = """
	!!!DEPRECATION WARNING!!!
	Your config is using old namespace for RemoteIp Plug. Setting should work for now, but you are advised to change to new namespace to prevent possible issues later:
	"""

	move_namespace_and_warn(
	[
	{Pleroma.Plugs.RemoteIp, Pleroma.Web.Plugs.RemoteIp,
	"\n* `config :pleroma, Pleroma.Plugs.RemoteIp` is now `config :pleroma, Pleroma.Web.Plugs.RemoteIp`"}
	],
	warning_preface
	)
	end

	- @spec check_uploaders_s3_public_endpoint() :: :ok \| nil
	+ @spec check_uploaders_s3_public_endpoint() :: :ok \| :error
	def check_uploaders_s3_public_endpoint do
	s3_config = Pleroma.Config.get([Pleroma.Uploaders.S3])

	use_old_config = Keyword.has_key?(s3_config, :public_endpoint)

	if use_old_config do
	Logger.error("""
	!!!DEPRECATION WARNING!!!
	Your config is using the old setting for controlling the URL of media uploaded to your S3 bucket.\n
	Please make the following change at your earliest convenience.\n
	\n* `config :pleroma, Pleroma.Uploaders.S3, public_endpoint` is now equal to:
	\n* `config :pleroma, Pleroma.Upload, base_url`
	""")

	:error
	else
	:ok
	end
	end

	- @spec check_old_chat_shoutbox() :: :ok \| nil
	+ @spec check_old_chat_shoutbox() :: :ok \| :error
	def check_old_chat_shoutbox do
	instance_config = Pleroma.Config.get([:instance])
	chat_config = Pleroma.Config.get([:chat]) \|\| []

	use_old_config =
	Keyword.has_key?(instance_config, :chat_limit) or
	Keyword.has_key?(chat_config, :enabled)

	if use_old_config do
	Logger.error("""
	!!!DEPRECATION WARNING!!!
	Your config is using the old namespace for the Shoutbox configuration. You need to convert to the new namespace. e.g.,
	\n* `config :pleroma, :chat, enabled` and `config :pleroma, :instance, chat_limit` are now equal to:
	\n* `config :pleroma, :shout, enabled` and `config :pleroma, :shout, limit`
	""")

	:error
	else
	:ok
	end
	end
	end
	diff --git a/lib/pleroma/emoji/pack.ex b/lib/pleroma/emoji/pack.ex
	index 85f7e1877..afc341853 100644
	--- a/lib/pleroma/emoji/pack.ex
	+++ b/lib/pleroma/emoji/pack.ex
	@@ -1,661 +1,661 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji.Pack do
	@derive {Jason.Encoder, only: [:files, :pack, :files_count]}
	defstruct files: %{},
	files_count: 0,
	pack_file: nil,
	path: nil,
	pack: %{},
	name: nil

	@type t() :: %__MODULE__{
	files: %{String.t() => Path.t()},
	files_count: non_neg_integer(),
	pack_file: Path.t(),
	path: Path.t(),
	pack: map(),
	name: String.t()
	}

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

	alias Pleroma.Emoji
	alias Pleroma.Emoji.Pack
	alias Pleroma.Utils

	@spec create(String.t()) :: {:ok, t()} \| {:error, File.posix()} \| {:error, :empty_values}
	def create(name) do
	with :ok <- validate_not_empty([name]),
	dir <- Path.join(emoji_path(), name),
	:ok <- File.mkdir(dir) do
	save_pack(%__MODULE__{pack_file: Path.join(dir, "pack.json")})
	end
	end

	defp paginate(entities, 1, page_size), do: Enum.take(entities, page_size)

	defp paginate(entities, page, page_size) do
	entities
	\|> Enum.chunk_every(page_size)
	\|> Enum.at(page - 1)
	end

	@spec show(keyword()) :: {:ok, t()} \| {:error, atom()}
	def show(opts) do
	name = opts[:name]

	with :ok <- validate_not_empty([name]),
	{:ok, pack} <- load_pack(name) do
	shortcodes =
	pack.files
	\|> Map.keys()
	\|> Enum.sort()
	\|> paginate(opts[:page], opts[:page_size])

	pack = Map.put(pack, :files, Map.take(pack.files, shortcodes))

	{:ok, validate_pack(pack)}
	end
	end

	@spec delete(String.t()) ::
	{:ok, [binary()]} \| {:error, File.posix(), binary()} \| {:error, :empty_values}
	def delete(name) do
	with :ok <- validate_not_empty([name]),
	pack_path <- Path.join(emoji_path(), name) do
	File.rm_rf(pack_path)
	end
	end

	@spec unpack_zip_emojies(list(tuple())) :: list(map())
	defp unpack_zip_emojies(zip_files) do
	Enum.reduce(zip_files, [], fn
	{_, path, s, _, _, _}, acc when elem(s, 2) == :regular ->
	with(
	filename <- Path.basename(path),
	shortcode <- Path.basename(filename, Path.extname(filename)),
	false <- Emoji.exist?(shortcode)
	) do
	[%{path: path, filename: path, shortcode: shortcode} \| acc]
	else
	_ -> acc
	end

	_, acc ->
	acc
	end)
	end

	@spec add_file(t(), String.t(), Path.t(), Plug.Upload.t()) ::
	{:ok, t()}
	\| {:error, File.posix() \| atom()}
	def add_file(%Pack{} = pack, _, _, %Plug.Upload{content_type: "application/zip"} = file) do
	with {:ok, zip_files} <- :zip.table(to_charlist(file.path)),
	[_ \| _] = emojies <- unpack_zip_emojies(zip_files),
	{:ok, tmp_dir} <- Utils.tmp_dir("emoji") do
	try do
	{:ok, _emoji_files} =
	:zip.unzip(
	to_charlist(file.path),
	- [{:file_list, Enum.map(emojies, & &1[:path])}, {:cwd, tmp_dir}]
	+ [{:file_list, Enum.map(emojies, & &1[:path])}, {:cwd, String.to_charlist(tmp_dir)}]
	)

	{_, updated_pack} =
	Enum.map_reduce(emojies, pack, fn item, emoji_pack ->
	emoji_file = %Plug.Upload{
	filename: item[:filename],
	path: Path.join(tmp_dir, item[:path])
	}

	{:ok, updated_pack} =
	do_add_file(
	emoji_pack,
	item[:shortcode],
	to_string(item[:filename]),
	emoji_file
	)

	{item, updated_pack}
	end)

	Emoji.reload()

	{:ok, updated_pack}
	after
	File.rm_rf(tmp_dir)
	end
	else
	{:error, _} = error ->
	error

	_ ->
	{:ok, pack}
	end
	end

	def add_file(%Pack{} = pack, shortcode, filename, %Plug.Upload{} = file) do
	with :ok <- validate_not_empty([shortcode, filename]),
	:ok <- validate_emoji_not_exists(shortcode),
	{:ok, updated_pack} <- do_add_file(pack, shortcode, filename, file) do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	defp do_add_file(pack, shortcode, filename, file) do
	with :ok <- save_file(file, pack, filename) do
	pack
	\|> put_emoji(shortcode, filename)
	\|> save_pack()
	end
	end

	@spec delete_file(t(), String.t()) ::
	{:ok, t()} \| {:error, File.posix() \| atom()}
	def delete_file(%Pack{} = pack, shortcode) do
	with :ok <- validate_not_empty([shortcode]),
	:ok <- remove_file(pack, shortcode),
	{:ok, updated_pack} <- pack \|> delete_emoji(shortcode) \|> save_pack() do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	@spec update_file(t(), String.t(), String.t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, File.posix() \| atom()}
	def update_file(%Pack{} = pack, shortcode, new_shortcode, new_filename, force) do
	with :ok <- validate_not_empty([shortcode, new_shortcode, new_filename]),
	{:ok, filename} <- get_filename(pack, shortcode),
	:ok <- validate_emoji_not_exists(new_shortcode, force),
	:ok <- rename_file(pack, filename, new_filename),
	{:ok, updated_pack} <-
	pack
	\|> delete_emoji(shortcode)
	\|> put_emoji(new_shortcode, new_filename)
	\|> save_pack() do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	@spec import_from_filesystem() :: {:ok, [String.t()]} \| {:error, File.posix() \| atom()}
	def import_from_filesystem do
	emoji_path = emoji_path()

	with {:ok, %{access: :read_write}} <- File.stat(emoji_path),
	{:ok, results} <- File.ls(emoji_path) do
	names =
	results
	\|> Enum.map(&Path.join(emoji_path, &1))
	\|> Enum.reject(fn path ->
	File.dir?(path) and File.exists?(Path.join(path, "pack.json"))
	end)
	\|> Enum.map(&write_pack_contents/1)
	\|> Enum.reject(&is_nil/1)

	{:ok, names}
	else
	{:ok, %{access: _}} -> {:error, :no_read_write}
	e -> e
	end
	end

	@spec list_remote(keyword()) :: {:ok, map()} \| {:error, atom()}
	def list_remote(opts) do
	uri = opts[:url] \|> String.trim() \|> URI.parse()

	with :ok <- validate_shareable_packs_available(uri) do
	uri
	\|> URI.merge(
	"/api/v1/pleroma/emoji/packs?page=#{opts[:page]}&page_size=#{opts[:page_size]}"
	)
	\|> http_get()
	end
	end

	@spec list_local(keyword()) :: {:ok, map(), non_neg_integer()}
	def list_local(opts) do
	with {:ok, results} <- list_packs_dir() do
	all_packs =
	results
	\|> Enum.map(fn name ->
	case load_pack(name) do
	{:ok, pack} -> pack
	_ -> nil
	end
	end)
	\|> Enum.reject(&is_nil/1)

	packs =
	all_packs
	\|> paginate(opts[:page], opts[:page_size])
	\|> Map.new(fn pack -> {pack.name, validate_pack(pack)} end)

	{:ok, packs, length(all_packs)}
	end
	end

	@spec get_archive(String.t()) :: {:ok, binary()} \| {:error, atom()}
	def get_archive(name) do
	with {:ok, pack} <- load_pack(name),
	:ok <- validate_downloadable(pack) do
	{:ok, fetch_archive(pack)}
	end
	end

	@spec download(String.t(), String.t(), String.t()) :: {:ok, t()} \| {:error, atom()}
	def download(name, url, as) do
	uri = url \|> String.trim() \|> URI.parse()

	with :ok <- validate_shareable_packs_available(uri),
	{:ok, %{"files_count" => files_count}} <-
	uri \|> URI.merge("/api/v1/pleroma/emoji/pack?name=#{name}&page_size=0") \|> http_get(),
	{:ok, remote_pack} <-
	uri
	\|> URI.merge("/api/v1/pleroma/emoji/pack?name=#{name}&page_size=#{files_count}")
	\|> http_get(),
	{:ok, %{sha: sha, url: url} = pack_info} <- fetch_pack_info(remote_pack, uri, name),
	{:ok, archive} <- download_archive(url, sha),
	pack <- copy_as(remote_pack, as \|\| name),
	{:ok, _} = unzip(archive, pack_info, remote_pack, pack) do
	# Fallback can't contain a pack.json file, since that would cause the fallback-src-sha256
	# in it to depend on itself
	if pack_info[:fallback] do
	save_pack(pack)
	else
	{:ok, pack}
	end
	end
	end

	@spec save_metadata(map(), t()) :: {:ok, t()} \| {:error, File.posix()}
	def save_metadata(metadata, %__MODULE__{} = pack) do
	pack
	\|> Map.put(:pack, metadata)
	\|> save_pack()
	end

	@spec update_metadata(String.t(), map()) :: {:ok, t()} \| {:error, File.posix()}
	def update_metadata(name, data) do
	with {:ok, pack} <- load_pack(name) do
	if fallback_sha_changed?(pack, data) do
	update_sha_and_save_metadata(pack, data)
	else
	save_metadata(data, pack)
	end
	end
	end

	@spec load_pack(String.t()) :: {:ok, t()} \| {:error, :file.posix()}
	def load_pack(name) do
	name = Path.basename(name)
	pack_file = Path.join([emoji_path(), name, "pack.json"])

	with {:ok, _} <- File.stat(pack_file),
	{:ok, pack_data} <- File.read(pack_file) do
	pack =
	from_json(
	pack_data,
	%{
	pack_file: pack_file,
	path: Path.dirname(pack_file),
	name: name
	}
	)

	files_count =
	pack.files
	\|> Map.keys()
	\|> length()

	{:ok, Map.put(pack, :files_count, files_count)}
	end
	end

	@spec emoji_path() :: Path.t()
	defp emoji_path do
	[:instance, :static_dir]
	\|> Pleroma.Config.get!()
	\|> Path.join("emoji")
	end

	defp validate_emoji_not_exists(shortcode, force \\ false)
	defp validate_emoji_not_exists(_shortcode, true), do: :ok

	defp validate_emoji_not_exists(shortcode, _) do
	if Emoji.exist?(shortcode) do
	{:error, :already_exists}
	else
	:ok
	end
	end

	defp write_pack_contents(path) do
	pack = %__MODULE__{
	files: files_from_path(path),
	path: path,
	pack_file: Path.join(path, "pack.json")
	}

	case save_pack(pack) do
	{:ok, _pack} -> Path.basename(path)
	_ -> nil
	end
	end

	defp files_from_path(path) do
	txt_path = Path.join(path, "emoji.txt")

	if File.exists?(txt_path) do
	# There's an emoji.txt file, it's likely from a pack installed by the pack manager.
	# Make a pack.json file from the contents of that emoji.txt file

	# FIXME: Copy-pasted from Pleroma.Emoji/load_from_file_stream/2

	# Create a map of shortcodes to filenames from emoji.txt
	txt_path
	\|> File.read!()
	\|> String.split("\n")
	\|> Enum.map(&String.trim/1)
	\|> Enum.map(fn line ->
	case String.split(line, ~r/,\s*/) do
	# This matches both strings with and without tags
	# and we don't care about tags here
	[name, file \| _] ->
	file_dir_name = Path.dirname(file)

	if String.ends_with?(path, file_dir_name) do
	{name, Path.basename(file)}
	else
	{name, file}
	end

	_ ->
	nil
	end
	end)
	\|> Enum.reject(&is_nil/1)
	\|> Map.new()
	else
	# If there's no emoji.txt, assume all files
	# that are of certain extensions from the config are emojis and import them all
	pack_extensions = Pleroma.Config.get!([:emoji, :pack_extensions])
	Emoji.Loader.make_shortcode_to_file_map(path, pack_extensions)
	end
	end

	defp validate_pack(pack) do
	info =
	if downloadable?(pack) do
	archive = fetch_archive(pack)
	archive_sha = :crypto.hash(:sha256, archive) \|> Base.encode16()

	pack.pack
	\|> Map.put("can-download", true)
	\|> Map.put("download-sha256", archive_sha)
	else
	Map.put(pack.pack, "can-download", false)
	end

	Map.put(pack, :pack, info)
	end

	defp downloadable?(pack) do
	# If the pack is set as shared, check if it can be downloaded
	# That means that when asked, the pack can be packed and sent to the remote
	# Otherwise, they'd have to download it from external-src
	pack.pack["share-files"] &&
	Enum.all?(pack.files, fn {_, file} ->
	pack.path
	\|> Path.join(file)
	\|> File.exists?()
	end)
	end

	defp create_archive_and_cache(pack, hash) do
	files = ['pack.json' \| Enum.map(pack.files, fn {_, file} -> to_charlist(file) end)]

	{:ok, {_, result}} =
	:zip.zip('#{pack.name}.zip', files, [:memory, cwd: to_charlist(pack.path)])

	ttl_per_file = Pleroma.Config.get!([:emoji, :shared_pack_cache_seconds_per_file])
	overall_ttl = :timer.seconds(ttl_per_file * Enum.count(files))

	@cachex.put(
	:emoji_packs_cache,
	pack.name,
	# if pack.json MD5 changes, the cache is not valid anymore
	%{hash: hash, pack_data: result},
	# Add a minute to cache time for every file in the pack
	ttl: overall_ttl
	)

	result
	end

	defp save_pack(pack) do
	with {:ok, json} <- Jason.encode(pack, pretty: true),
	:ok <- File.write(pack.pack_file, json) do
	{:ok, pack}
	end
	end

	defp from_json(json, attrs) do
	map = Jason.decode!(json)

	pack_attrs =
	attrs
	\|> Map.merge(%{
	files: map["files"],
	pack: map["pack"]
	})

	struct(__MODULE__, pack_attrs)
	end

	defp validate_shareable_packs_available(uri) do
	with {:ok, %{"links" => links}} <- uri \|> URI.merge("/.well-known/nodeinfo") \|> http_get(),
	# Get the actual nodeinfo address and fetch it
	{:ok, %{"metadata" => %{"features" => features}}} <-
	links \|> List.last() \|> Map.get("href") \|> http_get() do
	if Enum.member?(features, "shareable_emoji_packs") do
	:ok
	else
	{:error, :not_shareable}
	end
	end
	end

	defp validate_not_empty(list) do
	if Enum.all?(list, fn i -> is_binary(i) and i != "" end) do
	:ok
	else
	{:error, :empty_values}
	end
	end

	defp save_file(%Plug.Upload{path: upload_path}, pack, filename) do
	file_path = Path.join(pack.path, filename)
	create_subdirs(file_path)

	with {:ok, _} <- File.copy(upload_path, file_path) do
	:ok
	end
	end

	defp put_emoji(pack, shortcode, filename) do
	files = Map.put(pack.files, shortcode, filename)
	%{pack \| files: files, files_count: length(Map.keys(files))}
	end

	defp delete_emoji(pack, shortcode) do
	files = Map.delete(pack.files, shortcode)
	%{pack \| files: files}
	end

	defp rename_file(pack, filename, new_filename) do
	old_path = Path.join(pack.path, filename)
	new_path = Path.join(pack.path, new_filename)
	create_subdirs(new_path)

	with :ok <- File.rename(old_path, new_path) do
	remove_dir_if_empty(old_path, filename)
	end
	end

	defp create_subdirs(file_path) do
	with true <- String.contains?(file_path, "/"),
	path <- Path.dirname(file_path),
	false <- File.exists?(path) do
	File.mkdir_p!(path)
	end
	end

	defp remove_file(pack, shortcode) do
	with {:ok, filename} <- get_filename(pack, shortcode),
	emoji <- Path.join(pack.path, filename),
	:ok <- File.rm(emoji) do
	remove_dir_if_empty(emoji, filename)
	end
	end

	defp remove_dir_if_empty(emoji, filename) do
	dir = Path.dirname(emoji)

	if String.contains?(filename, "/") and File.ls!(dir) == [] do
	File.rmdir!(dir)
	else
	:ok
	end
	end

	defp get_filename(pack, shortcode) do
	with %{^shortcode => filename} when is_binary(filename) <- pack.files,
	file_path <- Path.join(pack.path, filename),
	{:ok, _} <- File.stat(file_path) do
	{:ok, filename}
	else
	{:error, _} = error ->
	error

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

	defp http_get(%URI{} = url), do: url \|> to_string() \|> http_get()

	defp http_get(url) do
	with {:ok, %{body: body}} <- Pleroma.HTTP.get(url, [], pool: :default) do
	Jason.decode(body)
	end
	end

	defp list_packs_dir do
	emoji_path = emoji_path()
	# Create the directory first if it does not exist. This is probably the first request made
	# with the API so it should be sufficient
	with {:create_dir, :ok} <- {:create_dir, File.mkdir_p(emoji_path)},
	{:ls, {:ok, results}} <- {:ls, File.ls(emoji_path)} do
	{:ok, Enum.sort(results)}
	else
	{:create_dir, {:error, e}} -> {:error, :create_dir, e}
	{:ls, {:error, e}} -> {:error, :ls, e}
	end
	end

	defp validate_downloadable(pack) do
	if downloadable?(pack), do: :ok, else: {:error, :cant_download}
	end

	defp copy_as(remote_pack, local_name) do
	path = Path.join(emoji_path(), local_name)

	%__MODULE__{
	name: local_name,
	path: path,
	files: remote_pack["files"],
	pack_file: Path.join(path, "pack.json")
	}
	end

	defp unzip(archive, pack_info, remote_pack, local_pack) do
	with :ok <- File.mkdir_p!(local_pack.path) do
	files = Enum.map(remote_pack["files"], fn {_, path} -> to_charlist(path) end)
	# Fallback cannot contain a pack.json file
	files = if pack_info[:fallback], do: files, else: ['pack.json' \| files]

	:zip.unzip(archive, cwd: to_charlist(local_pack.path), file_list: files)
	end
	end

	defp fetch_pack_info(remote_pack, uri, name) do
	case remote_pack["pack"] do
	%{"share-files" => true, "can-download" => true, "download-sha256" => sha} ->
	{:ok,
	%{
	sha: sha,
	url: URI.merge(uri, "/api/v1/pleroma/emoji/packs/archive?name=#{name}") \|> to_string()
	}}

	%{"fallback-src" => src, "fallback-src-sha256" => sha} when is_binary(src) ->
	{:ok,
	%{
	sha: sha,
	url: src,
	fallback: true
	}}

	_ ->
	{:error, "The pack was not set as shared and there is no fallback src to download from"}
	end
	end

	defp download_archive(url, sha) do
	with {:ok, %{body: archive}} <- Pleroma.HTTP.get(url) do
	if Base.decode16!(sha) == :crypto.hash(:sha256, archive) do
	{:ok, archive}
	else
	{:error, :invalid_checksum}
	end
	end
	end

	defp fetch_archive(pack) do
	hash = :crypto.hash(:md5, File.read!(pack.pack_file))

	case @cachex.get!(:emoji_packs_cache, pack.name) do
	%{hash: ^hash, pack_data: archive} -> archive
	_ -> create_archive_and_cache(pack, hash)
	end
	end

	defp fallback_sha_changed?(pack, data) do
	is_binary(data[:"fallback-src"]) and data[:"fallback-src"] != pack.pack["fallback-src"]
	end

	defp update_sha_and_save_metadata(pack, data) do
	with {:ok, %{body: zip}} <- Pleroma.HTTP.get(data[:"fallback-src"]),
	:ok <- validate_has_all_files(pack, zip) do
	fallback_sha = :sha256 \|> :crypto.hash(zip) \|> Base.encode16()

	data
	\|> Map.put("fallback-src-sha256", fallback_sha)
	\|> save_metadata(pack)
	end
	end

	defp validate_has_all_files(pack, zip) do
	with {:ok, f_list} <- :zip.unzip(zip, [:memory]) do
	# Check if all files from the pack.json are in the archive
	pack.files
	\|> Enum.all?(fn {_, from_manifest} ->
	List.keyfind(f_list, to_charlist(from_manifest), 0)
	end)
	\|> if(do: :ok, else: {:error, :incomplete})
	end
	end
	end
	diff --git a/lib/pleroma/filter.ex b/lib/pleroma/filter.ex
	index db88bc021..e827d3cbc 100644
	--- a/lib/pleroma/filter.ex
	+++ b/lib/pleroma/filter.ex
	@@ -1,226 +1,223 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Filter do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

	alias Pleroma.Repo
	alias Pleroma.User

	@type t() :: %__MODULE__{}
	@type format() :: :postgres \| :re

	schema "filters" do
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	field(:filter_id, :integer)
	field(:hide, :boolean, default: false)
	field(:whole_word, :boolean, default: true)
	field(:phrase, :string)
	field(:context, {:array, :string})
	field(:expires_at, :naive_datetime)

	timestamps()
	end

	@spec get(integer() \| String.t(), User.t()) :: t() \| nil
	def get(id, %{id: user_id} = _user) do
	query =
	from(
	f in __MODULE__,
	where: f.filter_id == ^id,
	where: f.user_id == ^user_id
	)

	Repo.one(query)
	end

	@spec get_active(Ecto.Query.t() \| module()) :: Ecto.Query.t()
	def get_active(query) do
	from(f in query, where: is_nil(f.expires_at) or f.expires_at > ^NaiveDateTime.utc_now())
	end

	@spec get_irreversible(Ecto.Query.t()) :: Ecto.Query.t()
	def get_irreversible(query) do
	from(f in query, where: f.hide)
	end

	@spec get_filters(Ecto.Query.t() \| module(), User.t()) :: [t()]
	def get_filters(query \\ __MODULE__, %User{id: user_id}) do
	query =
	from(
	f in query,
	where: f.user_id == ^user_id,
	order_by: [desc: :id]
	)

	Repo.all(query)
	end

	@spec create(map()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def create(attrs \\ %{}) do
	Repo.transaction(fn -> create_with_expiration(attrs) end)
	end

	defp create_with_expiration(attrs) do
	with {:ok, filter} <- do_create(attrs),
	{:ok, _} <- maybe_add_expiration_job(filter) do
	filter
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	defp do_create(attrs) do
	%__MODULE__{}
	\|> cast(attrs, [:phrase, :context, :hide, :expires_at, :whole_word, :user_id, :filter_id])
	\|> maybe_add_filter_id()
	\|> validate_required([:phrase, :context, :user_id, :filter_id])
	\|> maybe_add_expires_at(attrs)
	\|> Repo.insert()
	end

	defp maybe_add_filter_id(%{changes: %{filter_id: _}} = changeset), do: changeset

	defp maybe_add_filter_id(%{changes: %{user_id: user_id}} = changeset) do
	# If filter_id wasn't given, use the max filter_id for this user plus 1.
	# XXX This could result in a race condition if a user tries to add two
	# different filters for their account from two different clients at the
	# same time, but that should be unlikely.

	max_id_query =
	from(
	f in __MODULE__,
	where: f.user_id == ^user_id,
	select: max(f.filter_id)
	)

	filter_id =
	case Repo.one(max_id_query) do
	# Start allocating from 1
	nil ->
	1

	max_id ->
	max_id + 1
	end

	change(changeset, filter_id: filter_id)
	end

	# don't override expires_at, if passed expires_at and expires_in
	defp maybe_add_expires_at(%{changes: %{expires_at: %NaiveDateTime{} = _}} = changeset, _) do
	changeset
	end

	defp maybe_add_expires_at(changeset, %{expires_in: expires_in})
	when is_integer(expires_in) and expires_in > 0 do
	expires_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(expires_in)
	\|> NaiveDateTime.truncate(:second)

	change(changeset, expires_at: expires_at)
	end

	defp maybe_add_expires_at(changeset, %{expires_in: nil}) do
	change(changeset, expires_at: nil)
	end

	defp maybe_add_expires_at(changeset, _), do: changeset

	defp maybe_add_expiration_job(%{expires_at: %NaiveDateTime{} = expires_at} = filter) do
	Pleroma.Workers.PurgeExpiredFilter.enqueue(%{
	filter_id: filter.id,
	expires_at: DateTime.from_naive!(expires_at, "Etc/UTC")
	})
	end

	defp maybe_add_expiration_job(_), do: {:ok, nil}

	@spec delete(t()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def delete(%__MODULE__{} = filter) do
	Repo.transaction(fn -> delete_with_expiration(filter) end)
	end

	defp delete_with_expiration(filter) do
	with {:ok, _} <- maybe_delete_old_expiration_job(filter, nil),
	{:ok, filter} <- Repo.delete(filter) do
	filter
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec update(t(), map()) :: {:ok, t()} \| {:error, Ecto.Changeset.t()}
	def update(%__MODULE__{} = filter, params) do
	Repo.transaction(fn -> update_with_expiration(filter, params) end)
	end

	defp update_with_expiration(filter, params) do
	with {:ok, updated} <- do_update(filter, params),
	{:ok, _} <- maybe_delete_old_expiration_job(filter, updated),
	{:ok, _} <-
	maybe_add_expiration_job(updated) do
	updated
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	defp do_update(filter, params) do
	filter
	\|> cast(params, [:phrase, :context, :hide, :expires_at, :whole_word])
	\|> validate_required([:phrase, :context])
	\|> maybe_add_expires_at(params)
	\|> Repo.update()
	end

	defp maybe_delete_old_expiration_job(%{expires_at: nil}, _), do: {:ok, nil}

	defp maybe_delete_old_expiration_job(%{expires_at: expires_at}, %{expires_at: expires_at}) do
	{:ok, nil}
	end

	defp maybe_delete_old_expiration_job(%{id: id}, _) do
	with %Oban.Job{} = job <- Pleroma.Workers.PurgeExpiredFilter.get_expiration(id) do
	Repo.delete(job)
	else
	nil -> {:ok, nil}
	end
	end

	@spec compose_regex(User.t() \| [t()], format()) :: String.t() \| Regex.t() \| nil
	def compose_regex(user_or_filters, format \\ :postgres)

	def compose_regex(%User{} = user, format) do
	__MODULE__
	\|> get_active()
	\|> get_irreversible()
	\|> get_filters(user)
	\|> compose_regex(format)
	end

	def compose_regex([_ \| _] = filters, format) do
	phrases =
	filters
	\|> Enum.map(& &1.phrase)
	\|> Enum.join("\|")

	case format do
	:postgres ->
	"\\y(#{phrases})\\y"

	:re ->
	~r/\b#{phrases}\b/i
	-
	- _ ->
	- nil
	end
	end

	def compose_regex(_, _), do: nil
	end
	diff --git a/lib/pleroma/http/request_builder.ex b/lib/pleroma/http/request_builder.ex
	index f16fb3b35..0a028a64c 100644
	--- a/lib/pleroma/http/request_builder.ex
	+++ b/lib/pleroma/http/request_builder.ex
	@@ -1,95 +1,95 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTP.RequestBuilder do
	@moduledoc """
	Helper functions for building Tesla requests
	"""

	alias Pleroma.HTTP.Request
	alias Tesla.Multipart

	@doc """
	Creates new request
	"""
	@spec new(Request.t()) :: Request.t()
	def new(%Request{} = request \\ %Request{}), do: request

	@doc """
	Specify the request method when building a request
	"""
	@spec method(Request.t(), Request.method()) :: Request.t()
	def method(request, m), do: %{request \| method: m}

	@doc """
	Specify the request method when building a request
	"""
	@spec url(Request.t(), Request.url()) :: Request.t()
	def url(request, u), do: %{request \| url: u}

	@doc """
	Add headers to the request
	"""
	@spec headers(Request.t(), Request.headers()) :: Request.t()
	def headers(request, headers) do
	headers_list =
	with true <- Pleroma.Config.get([:http, :send_user_agent]),
	nil <- Enum.find(headers, fn {key, _val} -> String.downcase(key) == "user-agent" end) do
	[{"user-agent", Pleroma.Application.user_agent()} \| headers]
	else
	_ ->
	headers
	end

	%{request \| headers: headers_list}
	end

	@doc """
	Add custom, per-request middleware or adapter options to the request
	"""
	@spec opts(Request.t(), keyword()) :: Request.t()
	def opts(request, options), do: %{request \| opts: options}

	@doc """
	Add optional parameters to the request
	"""
	- @spec add_param(Request.t(), atom(), atom(), any()) :: Request.t()
	+ @spec add_param(Request.t(), atom(), atom() \| String.t(), any()) :: Request.t()
	def add_param(request, :query, :query, values), do: %{request \| query: values}

	def add_param(request, :body, :body, value), do: %{request \| body: value}

	- def add_param(request, :body, key, value) do
	+ def add_param(request, :body, key, value) when is_binary(key) do
	request
	\|> Map.put(:body, Multipart.new())
	\|> Map.update!(
	:body,
	&Multipart.add_field(
	&1,
	key,
	Jason.encode!(value),
	headers: [{"content-type", "application/json"}]
	)
	)
	end

	def add_param(request, :file, name, path) do
	request
	\|> Map.put(:body, Multipart.new())
	\|> Map.update!(:body, &Multipart.add_file(&1, path, name: name))
	end

	def add_param(request, :form, name, value) do
	Map.update(request, :body, %{name => value}, &Map.put(&1, name, value))
	end

	def add_param(request, location, key, value) do
	Map.update(request, location, [{key, value}], &(&1 ++ [{key, value}]))
	end

	def convert_to_keyword(request) do
	request
	\|> Map.from_struct()
	\|> Enum.into([])
	end
	end
	diff --git a/lib/pleroma/mfa.ex b/lib/pleroma/mfa.ex
	index 01b730c76..ce30cd4ad 100644
	--- a/lib/pleroma/mfa.ex
	+++ b/lib/pleroma/mfa.ex
	@@ -1,155 +1,155 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MFA do
	@moduledoc """
	The MFA context.
	"""

	alias Pleroma.User

	alias Pleroma.MFA.BackupCodes
	alias Pleroma.MFA.Changeset
	alias Pleroma.MFA.Settings
	alias Pleroma.MFA.TOTP

	@doc """
	Returns MFA methods the user has enabled.

	## Examples

	iex> Pleroma.MFA.supported_method(User)
	"totp, u2f"
	"""
	@spec supported_methods(User.t()) :: String.t()
	def supported_methods(user) do
	settings = fetch_settings(user)

	Settings.mfa_methods()
	\|> Enum.reduce([], fn m, acc ->
	if method_enabled?(m, settings) do
	acc ++ [m]
	else
	acc
	end
	end)
	\|> Enum.join(",")
	end

	@doc "Checks that user enabled MFA"
	def require?(user) do
	fetch_settings(user).enabled
	end

	@doc """
	Display MFA settings of user
	"""
	def mfa_settings(user) do
	settings = fetch_settings(user)

	Settings.mfa_methods()
	\|> Enum.map(fn m -> [m, method_enabled?(m, settings)] end)
	\|> Enum.into(%{enabled: settings.enabled}, fn [a, b] -> {a, b} end)
	end

	@doc false
	def fetch_settings(%User{} = user) do
	user.multi_factor_authentication_settings \|\| %Settings{}
	end

	@doc "clears backup codes"
	def invalidate_backup_code(%User{} = user, hash_code) do
	%{backup_codes: codes} = fetch_settings(user)

	user
	\|> Changeset.cast_backup_codes(codes -- [hash_code])
	\|> User.update_and_set_cache()
	end

	@doc "generates backup codes"
	@spec generate_backup_codes(User.t()) :: {:ok, list(binary)} \| {:error, String.t()}
	def generate_backup_codes(%User{} = user) do
	with codes <- BackupCodes.generate(),
	hashed_codes <- Enum.map(codes, &Pleroma.Password.Pbkdf2.hash_pwd_salt/1),
	changeset <- Changeset.cast_backup_codes(user, hashed_codes),
	{:ok, _} <- User.update_and_set_cache(changeset) do
	{:ok, codes}
	else
	{:error, msg} ->
	- %{error: msg}
	+ {:error, msg}
	end
	end

	@doc """
	Generates secret key and set delivery_type to 'app' for TOTP method.
	"""
	@spec setup_totp(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def setup_totp(user) do
	user
	\|> Changeset.setup_totp(%{secret: TOTP.generate_secret(), delivery_type: "app"})
	\|> User.update_and_set_cache()
	end

	@doc """
	Confirms the TOTP method for user.

	`attrs`:
	`password` - current user password
	`code` - TOTP token
	"""
	@spec confirm_totp(User.t(), map()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t() \| atom()}
	def confirm_totp(%User{} = user, attrs) do
	with settings <- user.multi_factor_authentication_settings.totp,
	{:ok, :pass} <- TOTP.validate_token(settings.secret, attrs["code"]) do
	user
	\|> Changeset.confirm_totp()
	\|> User.update_and_set_cache()
	end
	end

	@doc """
	Disables the TOTP method for user.

	`attrs`:
	`password` - current user password
	"""
	@spec disable_totp(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def disable_totp(%User{} = user) do
	user
	\|> Changeset.disable_totp()
	\|> Changeset.disable()
	\|> User.update_and_set_cache()
	end

	@doc """
	Force disables all MFA methods for user.
	"""
	@spec disable(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def disable(%User{} = user) do
	user
	\|> Changeset.disable_totp()
	\|> Changeset.disable(true)
	\|> User.update_and_set_cache()
	end

	@doc """
	Checks if the user has MFA method enabled.
	"""
	def method_enabled?(method, settings) do
	with {:ok, %{confirmed: true} = _} <- Map.fetch(settings, method) do
	true
	else
	_ -> false
	end
	end

	@doc """
	Checks if the user has enabled at least one MFA method.
	"""
	def enabled?(settings) do
	Settings.mfa_methods()
	\|> Enum.map(fn m -> method_enabled?(m, settings) end)
	\|> Enum.any?()
	end
	end
	diff --git a/lib/pleroma/mfa/totp.ex b/lib/pleroma/mfa/totp.ex
	index 429c4b700..96fa8d71d 100644
	--- a/lib/pleroma/mfa/totp.ex
	+++ b/lib/pleroma/mfa/totp.ex
	@@ -1,86 +1,87 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MFA.TOTP do
	@moduledoc """
	This module represents functions to create secrets for
	TOTP Application as well as validate them with a time based token.
	"""
	alias Pleroma.Config

	@config_ns [:instance, :multi_factor_authentication, :totp]

	@doc """
	https://github.com/google/google-authenticator/wiki/Key-Uri-Format
	"""
	+ @spec provisioning_uri(String.t(), String.t(), list()) :: String.t()
	def provisioning_uri(secret, label, opts \\ []) do
	query =
	%{
	secret: secret,
	issuer: Keyword.get(opts, :issuer, default_issuer()),
	digits: Keyword.get(opts, :digits, default_digits()),
	period: Keyword.get(opts, :period, default_period())
	}
	\|> Enum.filter(fn {_, v} -> not is_nil(v) end)
	\|> Enum.into(%{})
	\|> URI.encode_query()

	%URI{scheme: "otpauth", host: "totp", path: "/" <> label, query: query}
	- \|> URI.to_string()
	+ \|> to_string()
	end

	defp default_period, do: Config.get(@config_ns ++ [:period])
	defp default_digits, do: Config.get(@config_ns ++ [:digits])

	defp default_issuer,
	do: Config.get(@config_ns ++ [:issuer], Config.get([:instance, :name]))

	@doc "Creates a random Base 32 encoded string"
	def generate_secret do
	Base.encode32(:crypto.strong_rand_bytes(10))
	end

	@doc "Generates a valid token based on a secret"
	def generate_token(secret) do
	:pot.totp(secret)
	end

	@doc """
	Validates a given token based on a secret.

	optional parameters:
	`token_length` default `6`
	`interval_length` default `30`
	`window` default 0

	Returns {:ok, :pass} if the token is valid and
	{:error, :invalid_token} if it is not.
	"""
	@spec validate_token(String.t(), String.t()) ::
	{:ok, :pass} \| {:error, :invalid_token \| :invalid_secret_and_token}
	def validate_token(secret, token)
	when is_binary(secret) and is_binary(token) do
	opts = [
	token_length: default_digits(),
	interval_length: default_period()
	]

	validate_token(secret, token, opts)
	end

	def validate_token(_, _), do: {:error, :invalid_secret_and_token}

	@doc "See `validate_token/2`"
	@spec validate_token(String.t(), String.t(), Keyword.t()) ::
	{:ok, :pass} \| {:error, :invalid_token \| :invalid_secret_and_token}
	def validate_token(secret, token, options)
	when is_binary(secret) and is_binary(token) do
	case :pot.valid_totp(token, secret, options) do
	true -> {:ok, :pass}
	false -> {:error, :invalid_token}
	end
	end

	def validate_token(_, _, _), do: {:error, :invalid_secret_and_token}
	end
	diff --git a/lib/pleroma/pagination.ex b/lib/pleroma/pagination.ex
	index f12ca2819..8db732cc9 100644
	--- a/lib/pleroma/pagination.ex
	+++ b/lib/pleroma/pagination.ex
	@@ -1,165 +1,166 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Pagination do
	@moduledoc """
	Implements Mastodon-compatible pagination.
	"""

	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Repo

	@type type :: :keyset \| :offset

	@default_limit 20
	@max_limit 40
	@page_keys ["max_id", "min_id", "limit", "since_id", "order"]

	def page_keys, do: @page_keys

	@spec fetch_paginated(Ecto.Query.t(), map(), type(), atom() \| nil) :: [Ecto.Schema.t()]
	def fetch_paginated(query, params, type \\ :keyset, table_binding \\ nil)

	def fetch_paginated(query, %{total: true} = params, :keyset, table_binding) do
	total = Repo.aggregate(query, :count, :id)

	%{
	total: total,
	items: fetch_paginated(query, Map.drop(params, [:total]), :keyset, table_binding)
	}
	end

	def fetch_paginated(query, params, :keyset, table_binding) do
	options = cast_params(params)

	query
	\|> paginate(options, :keyset, table_binding)
	\|> Repo.all()
	\|> enforce_order(options)
	end

	def fetch_paginated(query, %{total: true} = params, :offset, table_binding) do
	total =
	query
	\|> Ecto.Query.exclude(:left_join)
	\|> Repo.aggregate(:count, :id)

	%{
	total: total,
	items: fetch_paginated(query, Map.drop(params, [:total]), :offset, table_binding)
	}
	end

	def fetch_paginated(query, params, :offset, table_binding) do
	options = cast_params(params)

	query
	\|> paginate(options, :offset, table_binding)
	\|> Repo.all()
	end

	- @spec paginate(Ecto.Query.t(), map(), type(), atom() \| nil) :: [Ecto.Schema.t()]
	- def paginate(query, options, method \\ :keyset, table_binding \\ nil)
	-
	- def paginate(list, options, _method, _table_binding) when is_list(list) do
	+ @spec paginate_list(list(), keyword()) :: list()
	+ def paginate_list(list, options) do
	offset = options[:offset] \|\| 0
	limit = options[:limit] \|\| 0
	Enum.slice(list, offset, limit)
	end

	+ @spec paginate(Ecto.Query.t(), map(), type(), atom() \| nil) :: [Ecto.Schema.t()]
	+ def paginate(query, options, method \\ :keyset, table_binding \\ nil)
	+
	def paginate(query, options, :keyset, table_binding) do
	query
	\|> restrict(:min_id, options, table_binding)
	\|> restrict(:since_id, options, table_binding)
	\|> restrict(:max_id, options, table_binding)
	\|> restrict(:order, options, table_binding)
	\|> restrict(:limit, options, table_binding)
	end

	def paginate(query, options, :offset, table_binding) do
	query
	\|> restrict(:order, options, table_binding)
	\|> restrict(:offset, options, table_binding)
	\|> restrict(:limit, options, table_binding)
	end

	defp cast_params(params) do
	param_types = %{
	min_id: :string,
	since_id: :string,
	max_id: :string,
	offset: :integer,
	limit: :integer,
	skip_extra_order: :boolean,
	skip_order: :boolean
	}

	changeset = cast({%{}, param_types}, params, Map.keys(param_types))
	changeset.changes
	end

	defp restrict(query, :min_id, %{min_id: min_id}, table_binding) do
	where(query, [{q, table_position(query, table_binding)}], q.id > ^min_id)
	end

	defp restrict(query, :since_id, %{since_id: since_id}, table_binding) do
	where(query, [{q, table_position(query, table_binding)}], q.id > ^since_id)
	end

	defp restrict(query, :max_id, %{max_id: max_id}, table_binding) do
	where(query, [{q, table_position(query, table_binding)}], q.id < ^max_id)
	end

	defp restrict(query, :order, %{skip_order: true}, _), do: query

	defp restrict(%{order_bys: [_ \| _]} = query, :order, %{skip_extra_order: true}, _), do: query

	defp restrict(query, :order, %{min_id: _}, table_binding) do
	order_by(
	query,
	[{u, table_position(query, table_binding)}],
	fragment("? asc nulls last", u.id)
	)
	end

	defp restrict(query, :order, _options, table_binding) do
	order_by(
	query,
	[{u, table_position(query, table_binding)}],
	fragment("? desc nulls last", u.id)
	)
	end

	defp restrict(query, :offset, %{offset: offset}, _table_binding) do
	offset(query, ^offset)
	end

	defp restrict(query, :limit, options, _table_binding) do
	limit =
	case Map.get(options, :limit, @default_limit) do
	limit when limit < @max_limit -> limit
	_ -> @max_limit
	end

	query
	\|> limit(^limit)
	end

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

	defp enforce_order(result, %{min_id: _}) do
	result
	\|> Enum.reverse()
	end

	defp enforce_order(result, _), do: result

	defp table_position(%Ecto.Query{} = query, binding_name) do
	Map.get(query.aliases, binding_name, 0)
	end

	defp table_position(_, _), do: 0
	end
	diff --git a/lib/pleroma/web/controller_helper.ex b/lib/pleroma/web/controller_helper.ex
	index d3cf372dc..1caf0f7e6 100644
	--- a/lib/pleroma/web/controller_helper.ex
	+++ b/lib/pleroma/web/controller_helper.ex
	@@ -1,120 +1,120 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ControllerHelper do
	use Pleroma.Web, :controller

	alias Pleroma.Pagination
	alias Pleroma.Web.Utils.Params

	def json_response(conn, status, _) when status in [204, :no_content] do
	conn
	\|> put_resp_header("content-type", "application/json")
	\|> send_resp(status, "")
	end

	def json_response(conn, status, json) do
	conn
	\|> put_status(status)
	\|> json(json)
	end

	- @spec fetch_integer_param(map(), String.t(), integer() \| nil) :: integer() \| nil
	+ @spec fetch_integer_param(map(), String.t() \| atom(), integer() \| nil) :: integer() \| nil
	def fetch_integer_param(params, name, default \\ nil) do
	params
	\|> Map.get(name, default)
	\|> param_to_integer(default)
	end

	defp param_to_integer(val, _) when is_integer(val), do: val

	defp param_to_integer(val, default) when is_binary(val) do
	case Integer.parse(val) do
	{res, _} -> res
	_ -> default
	end
	end

	defp param_to_integer(_, default), do: default

	def add_link_headers(conn, entries, extra_params \\ %{})

	def add_link_headers(%{assigns: %{skip_link_headers: true}} = conn, _entries, _extra_params),
	do: conn

	def add_link_headers(conn, entries, extra_params) do
	case get_pagination_fields(conn, entries, extra_params) do
	%{"next" => next_url, "prev" => prev_url} ->
	put_resp_header(conn, "link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")

	_ ->
	conn
	end
	end

	# TODO: Only fetch the params from open_api_spex when everything is converted
	@id_keys Pagination.page_keys() -- ["limit", "order"]
	defp build_pagination_fields(conn, min_id, max_id, extra_params) do
	params =
	if Map.has_key?(conn.private, :open_api_spex) do
	get_in(conn, [Access.key(:private), Access.key(:open_api_spex), Access.key(:params)])
	else
	conn.params
	end
	\|> Map.drop(Map.keys(conn.path_params) \|> Enum.map(&String.to_existing_atom/1))
	\|> Map.merge(extra_params)
	\|> Map.drop(@id_keys)

	%{
	"next" => current_url(conn, Map.put(params, :max_id, max_id)),
	"prev" => current_url(conn, Map.put(params, :min_id, min_id)),
	"id" => current_url(conn)
	}
	end

	def get_pagination_fields(conn, entries, extra_params \\ %{}) do
	case List.last(entries) do
	%{pagination_id: max_id} when not is_nil(max_id) ->
	%{pagination_id: min_id} = List.first(entries)

	build_pagination_fields(conn, min_id, max_id, extra_params)

	%{id: max_id} ->
	%{id: min_id} = List.first(entries)

	build_pagination_fields(conn, min_id, max_id, extra_params)

	_ ->
	%{}
	end
	end

	def assign_account_by_id(%{private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	case Pleroma.User.get_cached_by_id(id) do
	%Pleroma.User{} = account -> assign(conn, :account, account)
	nil -> Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found}) \|> halt()
	end
	end

	def try_render(conn, target, params) when is_binary(target) do
	render(conn, target, params)
	end

	def try_render(conn, _, _) do
	render_error(conn, :not_implemented, "Can't display this activity")
	end

	@doc """
	Returns true if request specifies to include embedded relationships in account objects.
	May only be used in selected account-related endpoints; has no effect for status- or
	notification-related endpoints.
	"""
	# Intended for PleromaFE: https://git.pleroma.social/pleroma/pleroma-fe/-/issues/838
	def embed_relationships?(params) do
	# To do once OpenAPI transition mess is over: just `truthy_param?(params[:with_relationships])`
	params
	\|> Map.get(:with_relationships, params["with_relationships"])
	\|> Params.truthy_param?()
	end
	end
	diff --git a/lib/pleroma/web/embed_controller.ex b/lib/pleroma/web/embed_controller.ex
	index ab0df9c5a..2ca4501a6 100644
	--- a/lib/pleroma/web/embed_controller.ex
	+++ b/lib/pleroma/web/embed_controller.ex
	@@ -1,42 +1,40 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.EmbedController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User

	alias Pleroma.Web.ActivityPub.Visibility

	- plug(:put_layout, :embed)
	-
	def show(conn, %{"id" => id}) do
	with %Activity{local: true} = activity <-
	Activity.get_by_id_with_object(id),
	true <- Visibility.public?(activity.object) do
	{:ok, author} = User.get_or_fetch(activity.object.data["actor"])

	conn
	\|> delete_resp_header("x-frame-options")
	\|> delete_resp_header("content-security-policy")
	\|> render("show.html",
	activity: activity,
	author: User.sanitize_html(author),
	counts: get_counts(activity)
	)
	end
	end

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

	%{
	likes: Map.get(data, "like_count", 0),
	replies: Map.get(data, "repliesCount", 0),
	announces: Map.get(data, "announcement_count", 0)
	}
	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 7fdf684d2..628aa311b 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/search_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/search_controller.ex
	@@ -1,202 +1,202 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	require Logger

	@search_limit 40

	plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)

	# 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}, private: %{open_api_spex: %{params: %{q: query} = params}}} =
	conn,
	_
	) 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}, private: %{open_api_spex: %{params: %{q: query} = params}}} =
	conn,
	_
	) 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: min(params[:limit], @search_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 -> Pleroma.Search.search(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 = 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)
	+ Pleroma.Pagination.paginate_list(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/o_auth/o_auth_controller.ex b/lib/pleroma/web/o_auth/o_auth_controller.ex
	index 2bbe5d5fa..47b03215f 100644
	--- a/lib/pleroma/web/o_auth/o_auth_controller.ex
	+++ b/lib/pleroma/web/o_auth/o_auth_controller.ex
	@@ -1,633 +1,628 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.OAuthController do
	use Pleroma.Web, :controller

	alias Pleroma.Helpers.AuthHelper
	alias Pleroma.Helpers.UriHelper
	alias Pleroma.Maps
	alias Pleroma.MFA
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.Auth.WrapperAuthenticator, as: Authenticator
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.MFAController
	alias Pleroma.Web.OAuth.MFAView
	alias Pleroma.Web.OAuth.OAuthView
	alias Pleroma.Web.OAuth.Scopes
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.OAuth.Token.Strategy.RefreshToken
	alias Pleroma.Web.OAuth.Token.Strategy.Revoke, as: RevokeToken
	alias Pleroma.Web.Plugs.RateLimiter
	alias Pleroma.Web.Utils.Params

	require Logger

	if Pleroma.Config.oauth_consumer_enabled?(), do: plug(Ueberauth)

	plug(:fetch_session)
	plug(:fetch_flash)

	plug(:skip_auth)

	plug(RateLimiter, [name: :authentication] when action == :create_authorization)

	action_fallback(Pleroma.Web.OAuth.FallbackController)

	@oob_token_redirect_uri "urn:ietf:wg:oauth:2.0:oob"

	# Note: this definition is only called from error-handling methods with `conn.params` as 2nd arg
	def authorize(%Plug.Conn{} = conn, %{"authorization" => _} = params) do
	{auth_attrs, params} = Map.pop(params, "authorization")
	authorize(conn, Map.merge(params, auth_attrs))
	end

	def authorize(%Plug.Conn{assigns: %{token: %Token{}}} = conn, %{"force_login" => _} = params) do
	if Params.truthy_param?(params["force_login"]) do
	do_authorize(conn, params)
	else
	handle_existing_authorization(conn, params)
	end
	end

	# Note: the token is set in oauth_plug, but the token and client do not always go together.
	# For example, MastodonFE's token is set if user requests with another client,
	# after user already authorized to MastodonFE.
	# So we have to check client and token.
	def authorize(
	%Plug.Conn{assigns: %{token: %Token{} = token}} = conn,
	%{"client_id" => client_id} = params
	) do
	with %Token{} = t <- Repo.get_by(Token, token: token.token) \|> Repo.preload(:app),
	^client_id <- t.app.client_id do
	handle_existing_authorization(conn, params)
	else
	_ -> do_authorize(conn, params)
	end
	end

	def authorize(%Plug.Conn{} = conn, params), do: do_authorize(conn, params)

	defp do_authorize(%Plug.Conn{} = conn, params) do
	app = Repo.get_by(App, client_id: params["client_id"])
	available_scopes = (app && app.scopes) \|\| []
	scopes = Scopes.fetch_scopes(params, available_scopes)

	user =
	with %{assigns: %{user: %User{} = user}} <- conn do
	user
	else
	_ -> nil
	end

	scopes =
	if scopes == [] do
	available_scopes
	else
	scopes
	end

	# Note: `params` might differ from `conn.params`; use `@params` not `@conn.params` in template
	render(conn, Authenticator.auth_template(), %{
	user: user,
	app: app && Map.delete(app, :client_secret),
	response_type: params["response_type"],
	client_id: params["client_id"],
	available_scopes: available_scopes,
	scopes: scopes,
	redirect_uri: params["redirect_uri"],
	state: params["state"],
	params: params
	})
	end

	defp handle_existing_authorization(
	%Plug.Conn{assigns: %{token: %Token{} = token}} = conn,
	%{"redirect_uri" => @oob_token_redirect_uri}
	) do
	render(conn, "oob_token_exists.html", %{token: token})
	end

	defp handle_existing_authorization(
	%Plug.Conn{assigns: %{token: %Token{} = token}} = conn,
	%{} = params
	) do
	app = Repo.preload(token, :app).app

	redirect_uri =
	if is_binary(params["redirect_uri"]) do
	params["redirect_uri"]
	else
	default_redirect_uri(app)
	end

	if redirect_uri in String.split(app.redirect_uris) do
	redirect_uri = redirect_uri(conn, redirect_uri)
	url_params = %{access_token: token.token}
	url_params = Maps.put_if_present(url_params, :state, params["state"])
	url = UriHelper.modify_uri_params(redirect_uri, url_params)
	redirect(conn, external: url)
	else
	conn
	\|> put_flash(:error, dgettext("errors", "Unlisted redirect_uri."))
	\|> redirect(external: redirect_uri(conn, redirect_uri))
	end
	end

	def create_authorization(_, _, opts \\ [])

	def create_authorization(%Plug.Conn{assigns: %{user: %User{} = user}} = conn, params, []) do
	create_authorization(conn, params, user: user)
	end

	def create_authorization(%Plug.Conn{} = conn, %{"authorization" => _} = params, opts) do
	with {:ok, auth, user} <- do_create_authorization(conn, params, opts[:user]),
	{:mfa_required, _, _, false} <- {:mfa_required, user, auth, MFA.require?(user)} do
	after_create_authorization(conn, auth, params)
	else
	error ->
	handle_create_authorization_error(conn, error, params)
	end
	end

	def after_create_authorization(%Plug.Conn{} = conn, %Authorization{} = auth, %{
	"authorization" => %{"redirect_uri" => @oob_token_redirect_uri}
	}) do
	# Enforcing the view to reuse the template when calling from other controllers
	conn
	\|> put_view(OAuthView)
	\|> render("oob_authorization_created.html", %{auth: auth})
	end

	def after_create_authorization(%Plug.Conn{} = conn, %Authorization{} = auth, %{
	"authorization" => %{"redirect_uri" => redirect_uri} = auth_attrs
	}) do
	app = Repo.preload(auth, :app).app

	# An extra safety measure before we redirect (also done in `do_create_authorization/2`)
	if redirect_uri in String.split(app.redirect_uris) do
	redirect_uri = redirect_uri(conn, redirect_uri)
	url_params = %{code: auth.token}
	url_params = Maps.put_if_present(url_params, :state, auth_attrs["state"])
	url = UriHelper.modify_uri_params(redirect_uri, url_params)
	redirect(conn, external: url)
	else
	conn
	\|> put_flash(:error, dgettext("errors", "Unlisted redirect_uri."))
	\|> redirect(external: redirect_uri(conn, redirect_uri))
	end
	end

	defp handle_create_authorization_error(
	%Plug.Conn{} = conn,
	{:error, scopes_issue},
	%{"authorization" => _} = params
	)
	when scopes_issue in [:unsupported_scopes, :missing_scopes] do
	# Per https://github.com/tootsuite/mastodon/blob/
	# 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L39
	conn
	\|> put_flash(:error, dgettext("errors", "This action is outside the authorized scopes"))
	\|> put_status(:unauthorized)
	\|> authorize(params)
	end

	defp handle_create_authorization_error(
	%Plug.Conn{} = conn,
	{:account_status, :confirmation_pending},
	%{"authorization" => _} = params
	) do
	conn
	\|> put_flash(:error, dgettext("errors", "Your login is missing a confirmed e-mail address"))
	\|> put_status(:forbidden)
	\|> authorize(params)
	end

	defp handle_create_authorization_error(
	%Plug.Conn{} = conn,
	{:mfa_required, user, auth, _},
	params
	) do
	{:ok, token} = MFA.Token.create(user, auth)

	data = %{
	"mfa_token" => token.token,
	"redirect_uri" => params["authorization"]["redirect_uri"],
	"state" => params["authorization"]["state"]
	}

	MFAController.show(conn, data)
	end

	defp handle_create_authorization_error(
	%Plug.Conn{} = conn,
	{:account_status, :password_reset_pending},
	%{"authorization" => _} = params
	) do
	conn
	\|> put_flash(:error, dgettext("errors", "Password reset is required"))
	\|> put_status(:forbidden)
	\|> authorize(params)
	end

	defp handle_create_authorization_error(
	%Plug.Conn{} = conn,
	{:account_status, :deactivated},
	%{"authorization" => _} = params
	) do
	conn
	\|> put_flash(:error, dgettext("errors", "Your account is currently disabled"))
	\|> put_status(:forbidden)
	\|> authorize(params)
	end

	defp handle_create_authorization_error(%Plug.Conn{} = conn, error, %{"authorization" => _}) do
	Authenticator.handle_error(conn, error)
	end

	@doc "Renew access_token with refresh_token"
	def token_exchange(
	%Plug.Conn{} = conn,
	%{"grant_type" => "refresh_token", "refresh_token" => token} = _params
	) do
	with {:ok, app} <- Token.Utils.fetch_app(conn),
	{:ok, %{user: user} = token} <- Token.get_by_refresh_token(app, token),
	{:ok, token} <- RefreshToken.grant(token) do
	after_token_exchange(conn, %{user: user, token: token})
	else
	_error -> render_invalid_credentials_error(conn)
	end
	end

	def token_exchange(%Plug.Conn{} = conn, %{"grant_type" => "authorization_code"} = params) do
	with {:ok, app} <- Token.Utils.fetch_app(conn),
	fixed_token = Token.Utils.fix_padding(params["code"]),
	{:ok, auth} <- Authorization.get_by_token(app, fixed_token),
	%User{} = user <- User.get_cached_by_id(auth.user_id),
	{:ok, token} <- Token.exchange_token(app, auth) do
	after_token_exchange(conn, %{user: user, token: token})
	else
	error ->
	handle_token_exchange_error(conn, error)
	end
	end

	def token_exchange(
	%Plug.Conn{} = conn,
	%{"grant_type" => "password"} = params
	) do
	with {:ok, %User{} = user} <- Authenticator.get_user(conn),
	{:ok, app} <- Token.Utils.fetch_app(conn),
	requested_scopes <- Scopes.fetch_scopes(params, app.scopes),
	{:ok, token} <- login(user, app, requested_scopes) do
	after_token_exchange(conn, %{user: user, token: token})
	else
	error ->
	handle_token_exchange_error(conn, error)
	end
	end

	def token_exchange(
	%Plug.Conn{} = conn,
	%{"grant_type" => "password", "name" => name, "password" => _password} = params
	) do
	params =
	params
	\|> Map.delete("name")
	\|> Map.put("username", name)

	token_exchange(conn, params)
	end

	def token_exchange(%Plug.Conn{} = conn, %{"grant_type" => "client_credentials"} = _params) do
	with {:ok, app} <- Token.Utils.fetch_app(conn),
	{:ok, auth} <- Authorization.create_authorization(app, %User{}),
	{:ok, token} <- Token.exchange_token(app, auth) do
	after_token_exchange(conn, %{token: token})
	else
	_error ->
	handle_token_exchange_error(conn, :invalid_credentials)
	end
	end

	# Bad request
	def token_exchange(%Plug.Conn{} = conn, params), do: bad_request(conn, params)

	def after_token_exchange(%Plug.Conn{} = conn, %{token: token} = view_params) do
	conn
	\|> AuthHelper.put_session_token(token.token)
	\|> json(OAuthView.render("token.json", view_params))
	end

	defp handle_token_exchange_error(%Plug.Conn{} = conn, {:mfa_required, user, auth, _}) do
	conn
	\|> put_status(:forbidden)
	\|> json(build_and_response_mfa_token(user, auth))
	end

	defp handle_token_exchange_error(%Plug.Conn{} = conn, {:account_status, :deactivated}) do
	render_error(
	conn,
	:forbidden,
	"Your account is currently disabled",
	%{},
	"account_is_disabled"
	)
	end

	defp handle_token_exchange_error(
	%Plug.Conn{} = conn,
	{:account_status, :password_reset_pending}
	) do
	render_error(
	conn,
	:forbidden,
	"Password reset is required",
	%{},
	"password_reset_required"
	)
	end

	defp handle_token_exchange_error(%Plug.Conn{} = conn, {:account_status, :confirmation_pending}) do
	render_error(
	conn,
	:forbidden,
	"Your login is missing a confirmed e-mail address",
	%{},
	"missing_confirmed_email"
	)
	end

	defp handle_token_exchange_error(%Plug.Conn{} = conn, {:account_status, :approval_pending}) do
	render_error(
	conn,
	:forbidden,
	"Your account is awaiting approval.",
	%{},
	"awaiting_approval"
	)
	end

	defp handle_token_exchange_error(%Plug.Conn{} = conn, _error) do
	render_invalid_credentials_error(conn)
	end

	def token_revoke(%Plug.Conn{} = conn, %{"token" => token}) do
	with {:ok, %Token{} = oauth_token} <- Token.get_by_token(token),
	{:ok, oauth_token} <- RevokeToken.revoke(oauth_token) do
	conn =
	with session_token = AuthHelper.get_session_token(conn),
	%Token{token: ^session_token} <- oauth_token do
	AuthHelper.delete_session_token(conn)
	else
	_ -> conn
	end

	json(conn, %{})
	else
	_error ->
	# RFC 7009: invalid tokens [in the request] do not cause an error response
	json(conn, %{})
	end
	end

	def token_revoke(%Plug.Conn{} = conn, params), do: bad_request(conn, params)

	# Response for bad request
	defp bad_request(%Plug.Conn{} = conn, _) do
	render_error(conn, :internal_server_error, "Bad request")
	end

	@doc "Prepares OAuth request to provider for Ueberauth"
	def prepare_request(%Plug.Conn{} = conn, %{
	"provider" => provider,
	"authorization" => auth_attrs
	}) do
	scope =
	auth_attrs
	\|> Scopes.fetch_scopes([])
	\|> Scopes.to_string()

	state =
	auth_attrs
	\|> Map.delete("scopes")
	\|> Map.put("scope", scope)
	\|> Jason.encode!()

	params =
	auth_attrs
	\|> Map.drop(~w(scope scopes client_id redirect_uri))
	\|> Map.put("state", state)

	# Handing the request to Ueberauth
	redirect(conn, to: Routes.o_auth_path(conn, :request, provider, params))
	end

	def request(%Plug.Conn{} = conn, params) do
	message =
	if params["provider"] do
	dgettext("errors", "Unsupported OAuth provider: %{provider}.",
	provider: params["provider"]
	)
	else
	dgettext("errors", "Bad OAuth request.")
	end

	conn
	\|> put_flash(:error, message)
	\|> redirect(to: "/")
	end

	def callback(%Plug.Conn{assigns: %{ueberauth_failure: failure}} = conn, params) do
	params = callback_params(params)
	messages = for e <- Map.get(failure, :errors, []), do: e.message
	message = Enum.join(messages, "; ")

	conn
	\|> put_flash(
	:error,
	dgettext("errors", "Failed to authenticate: %{message}.", message: message)
	)
	\|> redirect(external: redirect_uri(conn, params["redirect_uri"]))
	end

	def callback(%Plug.Conn{} = conn, params) do
	params = callback_params(params)

	with {:ok, registration} <- Authenticator.get_registration(conn) do
	auth_attrs = Map.take(params, ~w(client_id redirect_uri scope scopes state))

	case Repo.get_assoc(registration, :user) do
	{:ok, user} ->
	create_authorization(conn, %{"authorization" => auth_attrs}, user: user)

	_ ->
	registration_params =
	Map.merge(auth_attrs, %{
	"nickname" => Registration.nickname(registration),
	"email" => Registration.email(registration)
	})

	conn
	\|> put_session_registration_id(registration.id)
	\|> registration_details(%{"authorization" => registration_params})
	end
	else
	error ->
	Logger.debug(inspect(["OAUTH_ERROR", error, conn.assigns]))

	conn
	\|> put_flash(:error, dgettext("errors", "Failed to set up user account."))
	\|> redirect(external: redirect_uri(conn, params["redirect_uri"]))
	end
	end

	defp callback_params(%{"state" => state} = params) do
	Map.merge(params, Jason.decode!(state))
	end

	def registration_details(%Plug.Conn{} = conn, %{"authorization" => auth_attrs}) do
	render(conn, "register.html", %{
	client_id: auth_attrs["client_id"],
	redirect_uri: auth_attrs["redirect_uri"],
	state: auth_attrs["state"],
	scopes: Scopes.fetch_scopes(auth_attrs, []),
	nickname: auth_attrs["nickname"],
	email: auth_attrs["email"]
	})
	end

	def register(%Plug.Conn{} = conn, %{"authorization" => _, "op" => "connect"} = params) do
	with registration_id when not is_nil(registration_id) <- get_session_registration_id(conn),
	%Registration{} = registration <- Repo.get(Registration, registration_id),
	{_, {:ok, auth, _user}} <-
	{:create_authorization, do_create_authorization(conn, params)},
	%User{} = user <- Repo.preload(auth, :user).user,
	{:ok, _updated_registration} <- Registration.bind_to_user(registration, user) do
	conn
	\|> put_session_registration_id(nil)
	\|> after_create_authorization(auth, params)
	else
	{:create_authorization, error} ->
	{:register, handle_create_authorization_error(conn, error, params)}

	_ ->
	{:register, :generic_error}
	end
	end

	def register(%Plug.Conn{} = conn, %{"authorization" => _, "op" => "register"} = params) do
	with registration_id when not is_nil(registration_id) <- get_session_registration_id(conn),
	%Registration{} = registration <- Repo.get(Registration, registration_id),
	{:ok, user} <- Authenticator.create_from_registration(conn, registration) do
	conn
	\|> put_session_registration_id(nil)
	\|> create_authorization(
	params,
	user: user
	)
	else
	{:error, changeset} ->
	message =
	Enum.map(changeset.errors, fn {field, {error, _}} ->
	"#{field} #{error}"
	end)
	\|> Enum.join("; ")

	message =
	String.replace(
	message,
	"ap_id has already been taken",
	"nickname has already been taken"
	)

	conn
	\|> put_status(:forbidden)
	\|> put_flash(:error, "Error: #{message}.")
	\|> registration_details(params)

	_ ->
	{:register, :generic_error}
	end
	end

	defp do_create_authorization(conn, auth_attrs, user \\ nil)

	defp do_create_authorization(
	%Plug.Conn{} = conn,
	%{
	"authorization" =>
	%{
	"client_id" => client_id,
	"redirect_uri" => redirect_uri
	} = auth_attrs
	},
	user
	) do
	with {_, {:ok, %User{} = user}} <-
	{:get_user, (user && {:ok, user}) \|\| Authenticator.get_user(conn)},
	%App{} = app <- Repo.get_by(App, client_id: client_id),
	true <- redirect_uri in String.split(app.redirect_uris),
	requested_scopes <- Scopes.fetch_scopes(auth_attrs, app.scopes),
	{:ok, auth} <- do_create_authorization(user, app, requested_scopes) do
	{:ok, auth, user}
	end
	end

	defp do_create_authorization(%User{} = user, %App{} = app, requested_scopes)
	when is_list(requested_scopes) do
	with {:account_status, :active} <- {:account_status, User.account_status(user)},
	{:ok, scopes} <- validate_scopes(app, requested_scopes),
	{:ok, auth} <- Authorization.create_authorization(app, user, scopes) do
	{:ok, auth}
	end
	end

	# Note: intended to be a private function but opened for AccountController that logs in on signup
	@doc "If checks pass, creates authorization and token for given user, app and requested scopes."
	def login(%User{} = user, %App{} = app, requested_scopes) when is_list(requested_scopes) do
	with {:ok, auth} <- do_create_authorization(user, app, requested_scopes),
	{:mfa_required, _, _, false} <- {:mfa_required, user, auth, MFA.require?(user)},
	{:ok, token} <- Token.exchange_token(app, auth) do
	{:ok, token}
	end
	end

	defp redirect_uri(%Plug.Conn{}, redirect_uri), do: redirect_uri

	defp get_session_registration_id(%Plug.Conn{} = conn), do: get_session(conn, :registration_id)

	defp put_session_registration_id(%Plug.Conn{} = conn, registration_id),
	do: put_session(conn, :registration_id, registration_id)

	defp build_and_response_mfa_token(user, auth) do
	with {:ok, token} <- MFA.Token.create(user, auth) do
	MFAView.render("mfa_response.json", %{token: token, user: user})
	end
	end

	- @spec validate_scopes(App.t(), map() \| list()) ::
	+ @spec validate_scopes(App.t(), list()) ::
	{:ok, list()} \| {:error, :missing_scopes \| :unsupported_scopes}
	- defp validate_scopes(%App{} = app, params) when is_map(params) do
	- requested_scopes = Scopes.fetch_scopes(params, app.scopes)
	- validate_scopes(app, requested_scopes)
	- end
	-
	defp validate_scopes(%App{} = app, requested_scopes) when is_list(requested_scopes) do
	Scopes.validate(requested_scopes, app.scopes)
	end

	def default_redirect_uri(%App{} = app) do
	app.redirect_uris
	\|> String.split()
	\|> Enum.at(0)
	end

	defp render_invalid_credentials_error(conn) do
	render_error(conn, :bad_request, "Invalid credentials")
	end
	end
	diff --git a/lib/pleroma/web/o_status/o_status_controller.ex b/lib/pleroma/web/o_status/o_status_controller.ex
	index 4f2cf02c3..ee7ef4a5d 100644
	--- a/lib/pleroma/web/o_status/o_status_controller.ex
	+++ b/lib/pleroma/web/o_status/o_status_controller.ex
	@@ -1,140 +1,139 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.OStatusController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPubController
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Fallback.RedirectController
	alias Pleroma.Web.Metadata.PlayerView
	alias Pleroma.Web.Plugs.RateLimiter
	alias Pleroma.Web.Router

	plug(
	RateLimiter,
	[name: :ap_routes, params: ["uuid"]] when action in [:object, :activity]
	)

	plug(
	Pleroma.Web.Plugs.SetFormatPlug
	when action in [:object, :activity, :notice]
	)

	action_fallback(:errors)

	def object(%{assigns: %{format: format}} = conn, _params)
	when format in ["json", "activity+json"] do
	ActivityPubController.call(conn, :object)
	end

	def object(conn, _params) do
	with id <- Endpoint.url() <> conn.request_path,
	{_, %Activity{} = activity} <-
	{:activity, Activity.get_create_by_object_ap_id_with_object(id)},
	{_, true} <- {:public?, Visibility.public?(activity)} do
	redirect(conn, to: "/notice/#{activity.id}")
	else
	reason when reason in [{:public?, false}, {:activity, nil}] ->
	{:error, :not_found}

	e ->
	e
	end
	end

	def activity(%{assigns: %{format: format}} = conn, _params)
	when format in ["json", "activity+json"] do
	ActivityPubController.call(conn, :activity)
	end

	def activity(conn, _params) do
	with id <- Endpoint.url() <> conn.request_path,
	{_, %Activity{} = activity} <- {:activity, Activity.normalize(id)},
	{_, true} <- {:public?, Visibility.public?(activity)} do
	redirect(conn, to: "/notice/#{activity.id}")
	else
	reason when reason in [{:public?, false}, {:activity, nil}] ->
	{:error, :not_found}

	e ->
	e
	end
	end

	def notice(%{assigns: %{format: format}} = conn, %{"id" => id}) do
	with {_, %Activity{} = activity} <- {:activity, Activity.get_by_id_with_object(id)},
	{_, true} <- {:public?, Visibility.public?(activity)},
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	cond do
	format in ["json", "activity+json"] ->
	%{data: %{"id" => redirect_url}} = Object.normalize(activity, fetch: false)
	redirect(conn, external: redirect_url)

	activity.data["type"] == "Create" ->
	%Object{} = object = Object.normalize(activity, fetch: false)

	RedirectController.redirector_with_meta(
	conn,
	%{
	activity_id: activity.id,
	object: object,
	url: Router.Helpers.o_status_url(Endpoint, :notice, activity.id),
	user: user
	}
	)

	true ->
	RedirectController.redirector(conn, nil)
	end
	else
	reason when reason in [{:public?, false}, {:activity, nil}] ->
	conn
	\|> put_status(404)
	\|> RedirectController.redirector(nil, 404)

	e ->
	e
	end
	end

	# Returns an HTML embedded <audio> or <video> player suitable for embed iframes.
	def notice_player(conn, %{"id" => id}) do
	with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.public?(activity),
	{_, true} <- {:visible?, Visibility.visible_for_user?(activity, _reading_user = nil)},
	%Object{} = object <- Object.normalize(activity, fetch: false),
	%{data: %{"attachment" => [%{"url" => [url \| _]} \| _]}} <- object,
	true <- String.starts_with?(url["mediaType"], ["audio", "video"]) do
	conn
	- \|> put_layout(:metadata_player)
	\|> put_resp_header("x-frame-options", "ALLOW")
	\|> put_resp_header(
	"content-security-policy",
	"default-src 'none';style-src 'self' 'unsafe-inline';img-src 'self' data: https:; media-src 'self' https:;"
	)
	\|> put_view(PlayerView)
	\|> render("player.html", url)
	else
	_error ->
	conn
	\|> put_status(404)
	\|> RedirectController.redirector(nil, 404)
	end
	end

	defp errors(conn, {:error, :not_found}) do
	render_error(conn, :not_found, "Not found")
	end

	defp errors(conn, {:fetch_user, nil}), do: errors(conn, {:error, :not_found})

	defp errors(conn, _) do
	render_error(conn, :internal_server_error, "Something went wrong")
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/mascot_controller.ex b/lib/pleroma/web/pleroma_api/controllers/mascot_controller.ex
	index 5e412196b..3208cde98 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/mascot_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/mascot_controller.ex
	@@ -1,49 +1,49 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	plug(Majic.Plug, [pool: Pleroma.MajicPool] when action in [:update])
	plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)
	plug(OAuthScopesPlug, %{scopes: ["read:accounts"]} when action == :show)
	plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action != :show)

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

	@doc "GET /api/v1/pleroma/mascot"
	def show(%{assigns: %{user: user}} = conn, _params) do
	json(conn, User.get_mascot(user))
	end

	@doc "PUT /api/v1/pleroma/mascot"
	def update(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: %{file: file}}}} =
	conn,
	_
	) do
	with {:content_type, "image" <> _} <- {:content_type, file.content_type},
	- {:ok, object} <- ActivityPub.upload(file, actor: User.ap_id(user)) do
	+ {_, {:ok, object}} <- {:upload, ActivityPub.upload(file, actor: User.ap_id(user))} do
	attachment = render_attachment(object)
	{:ok, _user} = User.mascot_update(user, attachment)

	json(conn, attachment)
	else
	{:content_type, _} ->
	render_error(conn, :unsupported_media_type, "mascots can only be images")

	{:upload, {:error, _}} ->
	render_error(conn, :error, "error uploading file")
	end
	end

	defp render_attachment(object) do
	attachment_data = Map.put(object.data, "id", object.id)
	Pleroma.Web.MastodonAPI.StatusView.render("attachment.json", %{attachment: attachment_data})
	end
	end
	diff --git a/lib/pleroma/web/plugs/rate_limiter/supervisor.ex b/lib/pleroma/web/plugs/rate_limiter/supervisor.ex
	index f00f3d95e..5f79a3e3e 100644
	--- a/lib/pleroma/web/plugs/rate_limiter/supervisor.ex
	+++ b/lib/pleroma/web/plugs/rate_limiter/supervisor.ex
	@@ -1,20 +1,20 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Plugs.RateLimiter.Supervisor do
	use Supervisor

	def start_link(opts) do
	Supervisor.start_link(__MODULE__, opts, name: __MODULE__)
	end

	def init(_args) do
	children = [
	Pleroma.Web.Plugs.RateLimiter.LimiterSupervisor
	]

	- opts = [strategy: :one_for_one, name: Pleroma.Web.Streamer.Supervisor]
	+ opts = [strategy: :one_for_one]
	Supervisor.init(children, opts)
	end
	end
	diff --git a/lib/pleroma/web/static_fe/static_fe_controller.ex b/lib/pleroma/web/static_fe/static_fe_controller.ex
	index 3f2dbcd02..012f8e464 100644
	--- a/lib/pleroma/web/static_fe/static_fe_controller.ex
	+++ b/lib/pleroma/web/static_fe/static_fe_controller.ex
	@@ -1,188 +1,187 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.StaticFE.StaticFEController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Metadata
	alias Pleroma.Web.Router.Helpers

	- plug(:put_layout, :static_fe)
	plug(:assign_id)

	@page_keys ["max_id", "min_id", "limit", "since_id", "order"]

	@doc "Renders requested local public activity or public activities of requested user"
	def show(%{assigns: %{notice_id: notice_id}} = conn, _params) do
	with %Activity{local: true} = activity <-
	Activity.get_by_id_with_object(notice_id),
	true <- Visibility.public?(activity.object),
	{_, true} <- {:visible?, Visibility.visible_for_user?(activity, _reading_user = nil)},
	%User{} = user <- User.get_by_ap_id(activity.object.data["actor"]) do
	url = Helpers.url(conn) <> conn.request_path

	meta =
	Metadata.build_tags(%{
	activity_id: notice_id,
	object: activity.object,
	user: user,
	url: url
	})

	timeline =
	activity.object.data["context"]
	\|> ActivityPub.fetch_activities_for_context(%{})
	\|> Enum.reverse()
	\|> Enum.map(&represent(&1, &1.object.id == activity.object.id))

	render(conn, "conversation.html", %{activities: timeline, meta: meta})
	else
	%Activity{object: %Object{data: data}} ->
	conn
	\|> put_status(:found)
	\|> redirect(external: data["url"] \|\| data["external_url"] \|\| data["id"])

	_ ->
	not_found(conn, "Post not found.")
	end
	end

	def show(%{assigns: %{username_or_id: username_or_id}} = conn, params) do
	with {_, %User{local: true} = user} <-
	{:fetch_user, User.get_cached_by_nickname_or_id(username_or_id)},
	{_, :visible} <- {:visibility, User.visible_for(user, _reading_user = nil)} do
	meta = Metadata.build_tags(%{user: user})

	params =
	params
	\|> Map.take(@page_keys)
	\|> Map.new(fn {k, v} -> {String.to_existing_atom(k), v} end)

	timeline =
	user
	\|> ActivityPub.fetch_user_activities(_reading_user = nil, params)
	\|> Enum.map(&represent/1)

	prev_page_id =
	(params["min_id"] \|\| params["max_id"]) &&
	List.first(timeline) && List.first(timeline).id

	next_page_id = List.last(timeline) && List.last(timeline).id

	render(conn, "profile.html", %{
	user: User.sanitize_html(user),
	timeline: timeline,
	prev_page_id: prev_page_id,
	next_page_id: next_page_id,
	meta: meta
	})
	else
	_ ->
	not_found(conn, "User not found.")
	end
	end

	def show(%{assigns: %{object_id: _}} = conn, _params) do
	url = Helpers.url(conn) <> conn.request_path

	case Activity.get_create_by_object_ap_id_with_object(url) do
	%Activity{} = activity ->
	to = Helpers.o_status_path(Pleroma.Web.Endpoint, :notice, activity)
	redirect(conn, to: to)

	_ ->
	not_found(conn, "Post not found.")
	end
	end

	def show(%{assigns: %{activity_id: _}} = conn, _params) do
	url = Helpers.url(conn) <> conn.request_path

	case Activity.get_by_ap_id(url) do
	%Activity{} = activity ->
	to = Helpers.o_status_path(Pleroma.Web.Endpoint, :notice, activity)
	redirect(conn, to: to)

	_ ->
	not_found(conn, "Post not found.")
	end
	end

	defp get_title(%Object{data: %{"name" => name}}) when is_binary(name),
	do: name

	defp get_title(%Object{data: %{"summary" => summary}}) when is_binary(summary),
	do: summary

	defp get_title(_), do: nil

	defp not_found(conn, message) do
	conn
	\|> put_status(404)
	\|> render("error.html", %{message: message, meta: ""})
	end

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

	%{
	likes: data["like_count"] \|\| 0,
	replies: data["repliesCount"] \|\| 0,
	announces: data["announcement_count"] \|\| 0
	}
	end

	defp represent(%Activity{} = activity), do: represent(activity, false)

	defp represent(%Activity{object: %Object{data: data}} = activity, selected) do
	{:ok, user} = User.get_or_fetch(activity.object.data["actor"])

	link =
	case user.local do
	true -> Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	_ -> data["url"] \|\| data["external_url"] \|\| data["id"]
	end

	content =
	if data["content"] do
	data["content"]
	\|> Pleroma.HTML.filter_tags()
	\|> Pleroma.Emoji.Formatter.emojify(Map.get(data, "emoji", %{}))
	else
	nil
	end

	%{
	user: User.sanitize_html(user),
	title: get_title(activity.object),
	content: content,
	attachment: data["attachment"],
	link: link,
	published: data["published"],
	sensitive: data["sensitive"],
	selected: selected,
	counts: get_counts(activity),
	id: activity.id
	}
	end

	defp assign_id(%{path_info: ["notice", notice_id]} = conn, _opts),
	do: assign(conn, :notice_id, notice_id)

	defp assign_id(%{path_info: ["users", user_id]} = conn, _opts),
	do: assign(conn, :username_or_id, user_id)

	defp assign_id(%{path_info: ["objects", object_id]} = conn, _opts),
	do: assign(conn, :object_id, object_id)

	defp assign_id(%{path_info: ["activities", activity_id]} = conn, _opts),
	do: assign(conn, :activity_id, activity_id)

	defp assign_id(conn, _opts), do: conn
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 12:55 PM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723392
Default Alt Text: (109 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions