No OneTemporary
Actions

Authored By

Unknown

Size

72 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/noop-fixes.skip b/changelog.d/noop-fixes.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/lib/mix/pleroma.ex b/lib/mix/pleroma.ex
	index c01cf054d..e7869919c 100644
	--- a/lib/mix/pleroma.ex
	+++ b/lib/mix/pleroma.ex
	@@ -1,140 +1,144 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Pleroma do
	@apps [
	:restarter,
	:ecto,
	:ecto_sql,
	:postgrex,
	:db_connection,
	:cachex,
	:flake_id,
	:swoosh,
	:timex,
	:fast_html,
	:oban,
	:logger_backends
	]
	@cachex_children ["object", "user", "scrubber", "web_resp"]
	@doc "Common functions to be reused in mix tasks"
	def start_pleroma do
	Pleroma.Config.Holder.save_default()
	Pleroma.Config.Oban.warn()
	Pleroma.Application.limiters_setup()
	Application.put_env(:phoenix, :serve_endpoints, false, persistent: true)

	unless System.get_env("DEBUG") do
	- Logger.remove_backend(:console)
	+ try do
	+ Logger.remove_backend(:console)
	+ catch
	+ :exit, _ -> :ok
	+ end
	end

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

	apps =
	if adapter == Tesla.Adapter.Gun do
	[:gun \| @apps]
	else
	[:hackney \| @apps]
	end

	Enum.each(apps, &Application.ensure_all_started/1)

	oban_config = [
	crontab: [],
	repo: Pleroma.Repo,
	log: false,
	queues: [],
	plugins: []
	]

	children =
	[
	Pleroma.Repo,
	Pleroma.Emoji,
	{Pleroma.Config.TransferTask, false},
	Pleroma.Web.Endpoint,
	{Oban, oban_config},
	{Majic.Pool,
	[name: Pleroma.MajicPool, pool_size: Pleroma.Config.get([:majic_pool, :size], 2)]}
	] ++
	http_children(adapter)

	cachex_children = Enum.map(@cachex_children, &Pleroma.Application.build_cachex(&1, []))

	Supervisor.start_link(children ++ cachex_children,
	strategy: :one_for_one,
	name: Pleroma.Supervisor
	)

	if Pleroma.Config.get(:env) not in [:test, :benchmark] do
	pleroma_rebooted?()
	end
	end

	defp pleroma_rebooted? do
	if Restarter.Pleroma.rebooted?() do
	:ok
	else
	Process.sleep(10)
	pleroma_rebooted?()
	end
	end

	def load_pleroma do
	Application.load(:pleroma)
	end

	def get_option(options, opt, prompt, defval \\ nil, defname \\ nil) do
	Keyword.get(options, opt) \|\| shell_prompt(prompt, defval, defname)
	end

	def shell_prompt(prompt, defval \\ nil, defname \\ nil) do
	prompt_message = "#{prompt} [#{defname \|\| defval}] "

	input =
	if mix_shell?(),
	do: Mix.shell().prompt(prompt_message),
	else: :io.get_line(prompt_message)

	case input do
	"\n" ->
	case defval do
	nil ->
	shell_prompt(prompt, defval, defname)

	defval ->
	defval
	end

	input ->
	String.trim(input)
	end
	end

	def shell_info(message) do
	if mix_shell?(),
	do: Mix.shell().info(message),
	else: IO.puts(message)
	end

	def shell_error(message) do
	if mix_shell?(),
	do: Mix.shell().error(message),
	else: IO.puts(:stderr, message)
	end

	@doc "Performs a safe check whether `Mix.shell/0` is available (does not raise if Mix is not loaded)"
	def mix_shell?, do: :erlang.function_exported(Mix, :shell, 0)

	def escape_sh_path(path) do
	~S(') <> String.replace(path, ~S('), ~S(\')) <> ~S(')
	end

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

	defp http_children(_), do: []
	end
	diff --git a/lib/pleroma/language/translation/provider.ex b/lib/pleroma/language/translation/provider.ex
	index 533b5355a..4b423247a 100644
	--- a/lib/pleroma/language/translation/provider.ex
	+++ b/lib/pleroma/language/translation/provider.ex
	@@ -1,40 +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.Language.Translation.Provider do
	alias Pleroma.Language.Translation.Provider

	@callback missing_dependencies() :: [String.t()]

	@callback configured?() :: boolean()

	@callback translate(
	content :: String.t(),
	source_language :: String.t(),
	target_language :: String.t()
	) ::
	{:ok,
	%{
	content: String.t(),
	detected_source_language: String.t(),
	provider: String.t()
	}}
	\| {:error, atom()}

	@callback supported_languages(type :: :string \| :target) ::
	{:ok, [String.t()]} \| {:error, atom()}

	- @callback languages_matrix() :: {:ok, Map.t()} \| {:error, atom()}
	+ @callback languages_matrix() :: {:ok, map()} \| {:error, atom()}

	@callback name() :: String.t()

	defmacro __using__(_opts) do
	quote do
	@impl Provider
	def missing_dependencies, do: []

	defoverridable missing_dependencies: 0
	end
	end
	end
	diff --git a/lib/pleroma/object/fetcher.ex b/lib/pleroma/object/fetcher.ex
	index b54ef9ce5..c02069ecc 100644
	--- a/lib/pleroma/object/fetcher.ex
	+++ b/lib/pleroma/object/fetcher.ex
	@@ -1,261 +1,254 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.Fetcher do
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Signature
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Federator

	require Logger
	require Pleroma.Constants

	- @mix_env Mix.env()
	-
	@spec reinject_object(struct(), map()) :: {:ok, Object.t()} \| {:error, any()}
	defp reinject_object(%Object{data: %{}} = object, new_data) do
	Logger.debug("Reinjecting object #{new_data["id"]}")

	with {:ok, new_data, _} <- ObjectValidator.validate(new_data, %{}),
	{:ok, new_data} <- MRF.filter(new_data),
	{:ok, new_object, _} <-
	Object.Updater.do_update_and_invalidate_cache(
	object,
	new_data,
	_touch_changeset? = true
	) do
	{:ok, new_object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	defp reinject_object(_, new_data) do
	with {:ok, object, _} <- Pipeline.common_pipeline(new_data, local: false) do
	{:ok, object}
	else
	e -> e
	end
	end

	def refetch_object(%Object{data: %{"id" => id}} = object) do
	with {:local, false} <- {:local, Object.local?(object)},
	{:ok, new_data} <- fetch_and_contain_remote_object_from_id(id),
	{:ok, object} <- reinject_object(object, new_data) do
	{:ok, object}
	else
	{:local, true} -> {:ok, object}
	e -> {:error, e}
	end
	end

	@typep fetcher_errors ::
	:error \| :reject \| :allowed_depth \| :fetch \| :containment \| :transmogrifier

	# Note: will create a Create activity, which we need internally at the moment.
	@spec fetch_object_from_id(String.t(), list()) ::
	{:ok, Object.t()} \| {fetcher_errors(), any()} \| Pipeline.errors()
	def fetch_object_from_id(id, options \\ []) do
	with {_, nil} <- {:fetch_object, Object.get_cached_by_ap_id(id)},
	{_, true} <- {:allowed_depth, Federator.allowed_thread_distance?(options[:depth])},
	{_, {:ok, data}} <- {:fetch, fetch_and_contain_remote_object_from_id(id)},
	{_, nil} <- {:normalize, Object.normalize(data, fetch: false)},
	params <- prepare_activity_params(data),
	{_, :ok} <- {:containment, Containment.contain_origin(id, params)},
	{_, {:ok, activity}} <-
	{:transmogrifier, Transmogrifier.handle_incoming(params, options)},
	{_, _data, %Object{} = object} <-
	{:object, data, Object.normalize(activity, fetch: false)} do
	{:ok, object}
	else
	{:normalize, object = %Object{}} ->
	{:ok, object}

	{:fetch_object, %Object{} = object} ->
	{:ok, object}

	{:object, data, nil} ->
	reinject_object(%Object{}, data)

	e ->
	Logger.metadata(object: id)
	Logger.error("Object rejected while fetching #{id} #{inspect(e)}")
	e
	end
	end

	defp prepare_activity_params(data) do
	%{
	"type" => "Create",
	# Should we seriously keep this attributedTo thing?
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	}
	\|> Maps.put_if_present("to", data["to"])
	\|> Maps.put_if_present("cc", data["cc"])
	\|> Maps.put_if_present("bto", data["bto"])
	\|> Maps.put_if_present("bcc", data["bcc"])
	end

	defp make_signature(id, date) do
	uri = URI.parse(id)

	signature =
	InternalFetchActor.get_actor()
	\|> Signature.sign(%{
	"(request-target)": "get #{uri.path}",
	host: uri.host,
	date: date
	})

	{"signature", signature}
	end

	defp sign_fetch(headers, id, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[make_signature(id, date) \| headers]
	else
	headers
	end
	end

	defp maybe_date_fetch(headers, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[{"date", date} \| headers]
	else
	headers
	end
	end

	def fetch_and_contain_remote_object_from_id(id)

	def fetch_and_contain_remote_object_from_id(%{"id" => id}),
	do: fetch_and_contain_remote_object_from_id(id)

	def fetch_and_contain_remote_object_from_id(id) when is_binary(id) do
	Logger.debug("Fetching object #{id} via AP")

	with {:scheme, true} <- {:scheme, String.starts_with?(id, "http")},
	{_, true} <- {:mrf, MRF.id_filter(id)},
	{_, :ok} <- {:local_fetch, Containment.contain_local_fetch(id)},
	{:ok, body} <- get_object(id),
	{:ok, data} <- safe_json_decode(body),
	:ok <- Containment.contain_origin_from_id(id, data) do
	if not Instances.reachable?(id) do
	Instances.set_reachable(id)
	end

	{:ok, data}
	else
	{:scheme, _} ->
	{:error, "Unsupported URI scheme"}

	{:local_fetch, _} ->
	{:error, "Trying to fetch local resource"}

	{:error, e} ->
	{:error, e}

	{:mrf, false} ->
	{:error, {:reject, "Filtered by id"}}

	e ->
	{:error, e}
	end
	end

	def fetch_and_contain_remote_object_from_id(_id),
	do: {:error, "id must be a string"}

	- defp check_crossdomain_redirect(final_host, original_url)
	-
	- # Handle the common case in tests where responses don't include URLs
	- if @mix_env == :test do
	- defp check_crossdomain_redirect(nil, _) do
	- {:cross_domain_redirect, false}
	- end
	+ defp check_crossdomain_redirect(final_host, _original_url) when is_nil(final_host) do
	+ {:cross_domain_redirect, false}
	end

	defp check_crossdomain_redirect(final_host, original_url) do
	{:cross_domain_redirect, final_host != URI.parse(original_url).host}
	end

	defp get_object(id) do
	date = Pleroma.Signature.signed_date()

	headers =
	[{"accept", "application/activity+json"}]
	\|> maybe_date_fetch(date)
	\|> sign_fetch(id, date)

	case HTTP.get(id, headers) do
	{:ok, %{body: body, status: code, headers: headers, url: final_url}}
	when code in 200..299 ->
	remote_host = if final_url, do: URI.parse(final_url).host, else: nil

	with {:cross_domain_redirect, false} <- check_crossdomain_redirect(remote_host, id),
	{_, content_type} <- List.keyfind(headers, "content-type", 0),
	{:ok, _media_type} <- verify_content_type(content_type) do
	{:ok, body}
	else
	{:cross_domain_redirect, true} ->
	{:error, {:cross_domain_redirect, true}}

	error ->
	error
	end

	# Handle the case where URL is not in the response (older HTTP library versions)
	{:ok, %{body: body, status: code, headers: headers}} when code in 200..299 ->
	case List.keyfind(headers, "content-type", 0) do
	{_, content_type} ->
	case verify_content_type(content_type) do
	{:ok, _} -> {:ok, body}
	error -> error
	end

	_ ->
	{:error, {:content_type, nil}}
	end

	{:ok, %{status: code}} when code in [401, 403] ->
	{:error, :forbidden}

	{:ok, %{status: code}} when code in [404, 410] ->
	{:error, :not_found}

	{:error, e} ->
	{:error, e}

	e ->
	{:error, e}
	end
	end

	defp safe_json_decode(nil), do: {:ok, nil}
	defp safe_json_decode(json), do: Jason.decode(json)

	defp verify_content_type(content_type) do
	case Plug.Conn.Utils.media_type(content_type) do
	{:ok, "application", "activity+json", _} ->
	{:ok, :activity_json}

	{:ok, "application", "ld+json", %{"profile" => "https://www.w3.org/ns/activitystreams"}} ->
	{:ok, :ld_json}

	_ ->
	{:error, {:content_type, content_type}}
	end
	end
	end
	diff --git a/lib/pleroma/safe_zip.ex b/lib/pleroma/safe_zip.ex
	index 25fe434d6..ece18e645 100644
	--- a/lib/pleroma/safe_zip.ex
	+++ b/lib/pleroma/safe_zip.ex
	@@ -1,216 +1,212 @@
	# Akkoma: Magically expressive social media
	# Copyright © 2024 Akkoma Authors <https://akkoma.dev/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.SafeZip do
	@moduledoc """
	Wraps the subset of Erlang's zip module we’d like to use
	but enforces path-traversal safety everywhere and other checks.

	For convenience almost all functions accept both elixir strings and charlists,
	but output elixir strings themselves. However, this means the input parameter type
	can no longer be used to distinguish archive file paths from archive binary data in memory,
	thus where needed both a _data and _file variant are provided.
	"""

	@type text() :: String.t() \| [char()]

	defp safe_path?(path) do
	# Path accepts elixir’s chardata()
	case Path.safe_relative(path) do
	{:ok, _} -> true
	_ -> false
	end
	end

	defp safe_type?(file_type) do
	if file_type in [:regular, :directory] do
	true
	else
	false
	end
	end

	defp maybe_add_file(_type, _path_charlist, nil), do: nil

	defp maybe_add_file(:regular, path_charlist, file_list),
	do: [to_string(path_charlist) \| file_list]

	defp maybe_add_file(_type, _path_charlist, file_list), do: file_list

	@spec check_safe_archive_and_maybe_list_files(binary() \| [char()], [term()], boolean()) ::
	{:ok, [String.t()]} \| {:error, reason :: term()}
	defp check_safe_archive_and_maybe_list_files(archive, opts, list) do
	acc = if list, do: [], else: nil

	with {:ok, table} <- :zip.table(archive, opts) do
	Enum.reduce_while(table, {:ok, acc}, fn
	# ZIP comment
	{:zip_comment, _}, acc ->
	{:cont, acc}

	# File entry
	{:zip_file, path, info, _comment, _offset, _comp_size}, {:ok, fl} ->
	with {_, type} <- {:get_type, elem(info, 2)},
	{_, true} <- {:type, safe_type?(type)},
	{_, true} <- {:safe_path, safe_path?(path)} do
	{:cont, {:ok, maybe_add_file(type, path, fl)}}
	else
	- {:get_type, e} ->
	- {:halt,
	- {:error, "Couldn't determine file type of ZIP entry at #{path} (#{inspect(e)})"}}
	-
	{:type, _} ->
	{:halt, {:error, "Potentially unsafe file type in ZIP at: #{path}"}}

	{:safe_path, _} ->
	{:halt, {:error, "Unsafe path in ZIP: #{path}"}}
	end

	# new OTP version?
	_, _acc ->
	{:halt, {:error, "Unknown ZIP record type"}}
	end)
	end
	end

	@spec check_safe_archive_and_list_files(binary() \| [char()], [term()]) ::
	{:ok, [String.t()]} \| {:error, reason :: term()}
	defp check_safe_archive_and_list_files(archive, opts \\ []) do
	check_safe_archive_and_maybe_list_files(archive, opts, true)
	end

	@spec check_safe_archive(binary() \| [char()], [term()]) :: :ok \| {:error, reason :: term()}
	defp check_safe_archive(archive, opts \\ []) do
	case check_safe_archive_and_maybe_list_files(archive, opts, false) do
	{:ok, _} -> :ok
	error -> error
	end
	end

	@spec check_safe_file_list([text()], text()) :: :ok \| {:error, term()}
	defp check_safe_file_list([], _), do: :ok

	defp check_safe_file_list([path \| tail], cwd) do
	with {_, true} <- {:path, safe_path?(path)},
	{_, {:ok, fstat}} <- {:stat, File.stat(Path.expand(path, cwd))},
	{_, true} <- {:type, safe_type?(fstat.type)} do
	check_safe_file_list(tail, cwd)
	else
	{:path, _} ->
	{:error, "Unsafe path escaping cwd: #{path}"}

	{:stat, e} ->
	{:error, "Unable to check file type of #{path}: #{inspect(e)}"}

	{:type, _} ->
	{:error, "Unsafe type at #{path}"}
	end
	end

	defp check_safe_file_list(_, _), do: {:error, "Malformed file_list"}

	@doc """
	Checks whether the archive data contais file entries for all paths from fset

	Note this really only accepts entries corresponding to regular _files_,
	if a path is contained as for example an directory, this does not count as a match.
	"""
	@spec contains_all_data?(binary(), MapSet.t()) :: true \| false
	def contains_all_data?(archive_data, fset) do
	with {:ok, table} <- :zip.table(archive_data) do
	remaining =
	Enum.reduce(table, fset, fn
	{:zip_file, path, info, _comment, _offset, _comp_size}, fset ->
	if elem(info, 2) == :regular do
	MapSet.delete(fset, path)
	else
	fset
	end

	_, _ ->
	fset
	end)
	\|> MapSet.size()

	if remaining == 0, do: true, else: false
	else
	_ -> false
	end
	end

	@doc """
	List all file entries in ZIP, or error if invalid or unsafe.

	Note this really only lists regular files, no directories, ZIP comments or other types!
	"""
	@spec list_dir_file(text()) :: {:ok, [String.t()]} \| {:error, reason :: term()}
	def list_dir_file(archive) do
	path = to_charlist(archive)
	check_safe_archive_and_list_files(path)
	end

	defp stringify_zip({:ok, {fname, data}}), do: {:ok, {to_string(fname), data}}
	defp stringify_zip({:ok, fname}), do: {:ok, to_string(fname)}
	defp stringify_zip(ret), do: ret

	@spec zip(text(), text(), [text()], boolean()) ::
	{:ok, file_name :: String.t()}
	\| {:ok, {file_name :: String.t(), file_data :: binary()}}
	\| {:error, reason :: term()}
	def zip(name, file_list, cwd, memory \\ false) do
	opts = [{:cwd, to_charlist(cwd)}]
	opts = if memory, do: [:memory \| opts], else: opts

	with :ok <- check_safe_file_list(file_list, cwd) do
	file_list = for f <- file_list, do: to_charlist(f)
	name = to_charlist(name)
	stringify_zip(:zip.zip(name, file_list, opts))
	end
	end

	@spec unzip_file(text(), text(), [text()] \| nil) ::
	{:ok, [String.t()]}
	\| {:error, reason :: term()}
	\| {:error, {name :: text(), reason :: term()}}
	def unzip_file(archive, target_dir, file_list \\ nil) do
	do_unzip(to_charlist(archive), to_charlist(target_dir), file_list)
	end

	@spec unzip_data(binary(), text(), [text()] \| nil) ::
	{:ok, [String.t()]}
	\| {:error, reason :: term()}
	\| {:error, {name :: text(), reason :: term()}}
	def unzip_data(archive, target_dir, file_list \\ nil) do
	do_unzip(archive, to_charlist(target_dir), file_list)
	end

	defp stringify_unzip({:ok, [{_fname, _data} \| _] = filebinlist}),
	do: {:ok, Enum.map(filebinlist, fn {fname, data} -> {to_string(fname), data} end)}

	defp stringify_unzip({:ok, [_fname \| _] = filelist}),
	do: {:ok, Enum.map(filelist, fn fname -> to_string(fname) end)}

	defp stringify_unzip({:error, {fname, term}}), do: {:error, {to_string(fname), term}}
	defp stringify_unzip(ret), do: ret

	@spec do_unzip(binary() \| [char()], text(), [text()] \| nil) ::
	{:ok, [String.t()]}
	\| {:error, reason :: term()}
	\| {:error, {name :: text(), reason :: term()}}
	defp do_unzip(archive, target_dir, file_list) do
	opts =
	if file_list != nil do
	[
	file_list: for(f <- file_list, do: to_charlist(f)),
	cwd: target_dir
	]
	else
	[cwd: target_dir]
	end

	with :ok <- check_safe_archive(archive) do
	stringify_unzip(:zip.unzip(archive, opts))
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/remote_report_policy.ex b/lib/pleroma/web/activity_pub/mrf/remote_report_policy.ex
	index fa0610bf1..8422832dd 100644
	--- a/lib/pleroma/web/activity_pub/mrf/remote_report_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/remote_report_policy.ex
	@@ -1,118 +1,117 @@
	defmodule Pleroma.Web.ActivityPub.MRF.RemoteReportPolicy do
	@moduledoc "Drop remote reports if they don't contain enough information."
	@behaviour Pleroma.Web.ActivityPub.MRF.Policy

	alias Pleroma.Config

	@impl true
	def filter(%{"type" => "Flag"} = object) do
	with {_, false} <- {:local, local?(object)},
	{:ok, _} <- maybe_reject_all(object),
	{:ok, _} <- maybe_reject_anonymous(object),
	{:ok, _} <- maybe_reject_third_party(object),
	{:ok, _} <- maybe_reject_empty_message(object) do
	{:ok, object}
	else
	{:local, true} -> {:ok, object}
	{:reject, message} -> {:reject, message}
	- error -> {:reject, error}
	end
	end

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

	defp maybe_reject_all(object) do
	if Config.get([:mrf_remote_report, :reject_all]) do
	{:reject, "[RemoteReportPolicy] Remote report"}
	else
	{:ok, object}
	end
	end

	defp maybe_reject_anonymous(%{"actor" => actor} = object) do
	with true <- Config.get([:mrf_remote_report, :reject_anonymous]),
	%URI{path: "/actor"} <- URI.parse(actor) do
	{:reject, "[RemoteReportPolicy] Anonymous: #{actor}"}
	else
	_ -> {:ok, object}
	end
	end

	defp maybe_reject_third_party(%{"object" => objects} = object) do
	{_, to} =
	case objects do
	[head \| tail] when is_binary(head) -> {tail, head}
	s when is_binary(s) -> {[], s}
	_ -> {[], ""}
	end

	with true <- Config.get([:mrf_remote_report, :reject_third_party]),
	false <- String.starts_with?(to, Pleroma.Web.Endpoint.url()) do
	{:reject, "[RemoteReportPolicy] Third-party: #{to}"}
	else
	_ -> {:ok, object}
	end
	end

	defp maybe_reject_empty_message(%{"content" => content} = object)
	when is_binary(content) and content != "" do
	{:ok, object}
	end

	defp maybe_reject_empty_message(object) do
	if Config.get([:mrf_remote_report, :reject_empty_message]) do
	{:reject, ["RemoteReportPolicy] No content"]}
	else
	{:ok, object}
	end
	end

	defp local?(%{"actor" => actor}) do
	String.starts_with?(actor, Pleroma.Web.Endpoint.url())
	end

	@impl true
	def describe do
	mrf_remote_report =
	Config.get(:mrf_remote_report)
	\|> Enum.into(%{})

	{:ok, %{mrf_remote_report: mrf_remote_report}}
	end

	@impl true
	def config_description do
	%{
	key: :mrf_remote_report,
	related_policy: "Pleroma.Web.ActivityPub.MRF.RemoteReportPolicy",
	label: "MRF Remote Report",
	description: "Drop remote reports if they don't contain enough information.",
	children: [
	%{
	key: :reject_all,
	type: :boolean,
	description: "Reject all remote reports? (this option takes precedence)",
	suggestions: [false]
	},
	%{
	key: :reject_anonymous,
	type: :boolean,
	description: "Reject anonymous remote reports?",
	suggestions: [true]
	},
	%{
	key: :reject_third_party,
	type: :boolean,
	description: "Reject reports on users from third-party instances?",
	suggestions: [true]
	},
	%{
	key: :reject_empty_message,
	type: :boolean,
	description: "Reject remote reports with no message?",
	suggestions: [true]
	}
	]
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec.ex b/lib/pleroma/web/api_spec.ex
	index e5339097f..3e0ac3704 100644
	--- a/lib/pleroma/web/api_spec.ex
	+++ b/lib/pleroma/web/api_spec.ex
	@@ -1,163 +1,163 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec do
	alias OpenApiSpex.OpenApi
	alias OpenApiSpex.Operation
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router

	@behaviour OpenApi

	defp streaming_paths do
	%{
	"/api/v1/streaming" => %OpenApiSpex.PathItem{
	get: Pleroma.Web.ApiSpec.StreamingOperation.streaming_operation()
	}
	}
	end

	@impl OpenApi
	def spec(opts \\ []) do
	%OpenApi{
	servers:
	if opts[:server_specific] do
	[
	# Populate the Server info from a phoenix endpoint
	OpenApiSpex.Server.from_endpoint(Endpoint)
	]
	else
	[]
	end,
	info: %OpenApiSpex.Info{
	title: "Pleroma API",
	description: """
	This is documentation for client Pleroma API. Most of the endpoints and entities come
	from Mastodon API and have custom extensions on top.

	While this document aims to be a complete guide to the client API Pleroma exposes,
	the details are still being worked out. Some endpoints may have incomplete or poorly worded documentation.
	You might want to check the following resources if something is not clear:
	- [Legacy Pleroma-specific endpoint documentation](https://docs-develop.pleroma.social/backend/development/API/pleroma_api/)
	- [Mastodon API documentation](https://docs.joinmastodon.org/client/intro/)
	- [Differences in Mastodon API responses from vanilla Mastodon](https://docs-develop.pleroma.social/backend/development/API/differences_in_mastoapi_responses/)

	Please report such occurrences on our [issue tracker](https://git.pleroma.social/pleroma/pleroma/-/issues). Feel free to submit API questions or proposals there too!
	""",
	# Strip environment from the version
	version: Application.spec(:pleroma, :vsn) \|> to_string() \|> String.replace(~r/\+.*$/, ""),
	extensions: %{
	# Logo path should be picked so that the path exists both on Pleroma instances and on api.pleroma.social
	"x-logo": %{"url" => "/static/logo.svg", "altText" => "Pleroma logo"}
	}
	},
	# populate the paths from a phoenix router
	paths: Map.merge(streaming_paths(), OpenApiSpex.Paths.from_router(Router)),
	components: %OpenApiSpex.Components{
	parameters: %{
	"accountIdOrNickname" =>
	Operation.parameter(:id, :path, :string, "Account ID or nickname",
	example: "123",
	required: true
	)
	},
	securitySchemes: %{
	"oAuth" => %OpenApiSpex.SecurityScheme{
	type: "oauth2",
	flows: %OpenApiSpex.OAuthFlows{
	password: %OpenApiSpex.OAuthFlow{
	authorizationUrl: "/oauth/authorize",
	tokenUrl: "/oauth/token",
	scopes: %{
	# TODO: Document granular scopes
	"read" => "Read everything",
	"write" => "Write everything",
	"follow" => "Manage relationships",
	"push" => "Web Push API subscriptions"
	}
	}
	}
	}
	}
	},
	extensions: %{
	# Redoc-specific extension, every time a new tag is added it should be reflected here,
	# otherwise it won't be shown.
	"x-tagGroups": [
	%{
	"name" => "Accounts",
	"tags" => ["Account actions", "Retrieve account information", "Scrobbles"]
	},
	%{
	"name" => "Administration",
	"tags" => [
	"Chat administration",
	"Emoji pack administration",
	"Frontend management",
	"Instance configuration",
	"Instance documents",
	"Instance rule management",
	"Invites",
	"MediaProxy cache",
	"OAuth application management",
	"Relays",
	"Report management",
	"Status administration",
	"User administration",
	"Announcement management"
	]
	},
	%{"name" => "Applications", "tags" => ["Applications", "Push subscriptions"]},
	%{
	"name" => "Current account",
	"tags" => [
	"Account credentials",
	"Backups",
	"Blocks and mutes",
	"Data import",
	"Domain blocks",
	"Follow requests",
	"Mascot",
	"Markers",
	"Notifications",
	"Filters",
	"Settings"
	]
	},
	%{"name" => "Instance", "tags" => ["Custom emojis", "Instance misc"]},
	%{"name" => "Messaging", "tags" => ["Chats", "Conversations"]},
	%{
	"name" => "Statuses",
	"tags" => [
	"Emoji reactions",
	"Lists",
	"Polls",
	"Timelines",
	"Retrieve status information",
	"Scheduled statuses",
	"Search",
	"Status actions",
	"Media attachments",
	"Bookmark folders",
	"Tags"
	]
	},
	%{
	"name" => "Miscellaneous",
	"tags" => [
	"Emoji packs",
	"Reports",
	"Suggestions",
	"Announcements",
	"Remote interaction",
	"Others"
	]
	}
	]
	}
	}
	# discover request/response schemas from path specs
	- \|> OpenApiSpex.resolve_schema_modules()
	+ \|> then(&OpenApiSpex.resolve_schema_modules/1)
	end
	end
	diff --git a/lib/pleroma/web/api_spec/scopes/compiler.ex b/lib/pleroma/web/api_spec/scopes/compiler.ex
	index 162edc9a3..a92cf1199 100644
	--- a/lib/pleroma/web/api_spec/scopes/compiler.ex
	+++ b/lib/pleroma/web/api_spec/scopes/compiler.ex
	@@ -1,82 +1,86 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Scopes.Compiler do
	defmacro __before_compile__(_env) do
	strings = __MODULE__.extract_all_scopes()

	quote do
	def placeholder do
	unquote do
	Enum.map(
	strings,
	fn string ->
	quote do
	Pleroma.Web.Gettext.dgettext_noop(
	"oauth_scopes",
	unquote(string)
	)
	end
	end
	)
	end
	end
	end
	end

	def extract_all_scopes do
	- extract_all_scopes_from(Pleroma.Web.ApiSpec.spec())
	+ try do
	+ extract_all_scopes_from(Pleroma.Web.ApiSpec.spec())
	+ catch
	+ _, _ -> []
	+ end
	end

	def extract_all_scopes_from(specs) do
	specs.paths
	\|> Enum.reduce([], fn
	{_path, %{} = path_item}, acc ->
	extract_routes(path_item)
	\|> Enum.flat_map(fn operation -> process_operation(operation) end)
	\|> Kernel.++(acc)

	{_, _}, acc ->
	acc
	end)
	\|> Enum.uniq()
	end

	defp extract_routes(path_item) do
	path_item
	\|> Map.from_struct()
	\|> Enum.map(fn {_method, path_item} -> path_item end)
	\|> Enum.filter(fn
	%OpenApiSpex.Operation{} = _operation -> true
	_ -> false
	end)
	end

	defp process_operation(operation) do
	operation.security
	\|> Kernel.\|\|([])
	\|> Enum.flat_map(fn
	%{"oAuth" => scopes} -> process_scopes(scopes)
	_ -> []
	end)
	end

	defp process_scopes(scopes) do
	scopes
	\|> Enum.flat_map(fn scope ->
	process_scope(scope)
	end)
	end

	def process_scope(scope) do
	hierarchy = String.split(scope, ":")

	{_, list} =
	Enum.reduce(hierarchy, {"", []}, fn comp, {cur, list} ->
	{cur <> comp <> ":", [cur <> comp \| list]}
	end)

	list
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/status_controller.ex b/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	index 10549fb20..32874d464 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/status_controller.ex
	@@ -1,639 +1,642 @@
	# 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.StatusController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [try_render: 3, add_link_headers: 2]

	require Ecto.Query

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.BookmarkFolder
	alias Pleroma.Language.Translation
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.ScheduledActivityView
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter

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

	plug(:skip_public_check when action in [:index, :show])

	@unauthenticated_access %{fallback: :proceed_unauthenticated, scopes: []}

	plug(
	OAuthScopesPlug,
	%{@unauthenticated_access \| scopes: ["read:statuses"]}
	when action in [
	:index,
	:show,
	:context,
	:show_history,
	:show_source
	]
	)

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

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:statuses"]}
	when action in [
	:create,
	:delete,
	:reblog,
	:unreblog,
	:update
	]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:favourites"]} when action == :favourites)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:favourites"]} when action in [:favourite, :unfavourite]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:mutes"]} when action in [:mute_conversation, :unmute_conversation]
	)

	plug(
	OAuthScopesPlug,
	%{@unauthenticated_access \| scopes: ["read:accounts"]}
	when action in [:favourited_by, :reblogged_by]
	)

	plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action in [:pin, :unpin])

	# Note: scope not present in Mastodon: read:bookmarks
	plug(OAuthScopesPlug, %{scopes: ["read:bookmarks"]} when action == :bookmarks)

	# Note: scope not present in Mastodon: write:bookmarks
	plug(
	OAuthScopesPlug,
	%{scopes: ["write:bookmarks"]} when action in [:bookmark, :unbookmark]
	)

	@rate_limited_status_actions ~w(reblog unreblog favourite unfavourite create delete translate)a

	plug(
	RateLimiter,
	[name: :status_id_action, bucket_name: "status_id_action:reblog_unreblog", params: [:id]]
	when action in ~w(reblog unreblog)a
	)

	plug(
	RateLimiter,
	[name: :status_id_action, bucket_name: "status_id_action:fav_unfav", params: [:id]]
	when action in ~w(favourite unfavourite)a
	)

	plug(RateLimiter, [name: :statuses_actions] when action in @rate_limited_status_actions)

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

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

	@doc """
	GET `/api/v1/statuses?ids[]=1&ids[]=2`

	`ids` query param is required
	"""
	def index(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: params}}} =
	conn,
	_
	) do
	ids = Map.get(params, :id, Map.get(params, :ids))
	limit = 100

	activities =
	ids
	\|> Enum.take(limit)
	\|> Activity.all_by_ids_with_object()
	\|> Enum.filter(&Visibility.visible_for_user?(&1, user))

	render(conn, "index.json",
	activities: activities,
	for: user,
	as: :activity,
	with_muted: Map.get(params, :with_muted, false)
	)
	end

	@doc """
	POST /api/v1/statuses
	"""
	# Creates a scheduled status when `scheduled_at` param is present and it's far enough
	def create(
	%{
	assigns: %{user: user},
	private: %{
	open_api_spex: %{body_params: %{status: _, scheduled_at: scheduled_at} = params}
	}
	} = conn,
	_
	)
	when not is_nil(scheduled_at) do
	params =
	Map.put(params, :in_reply_to_status_id, params[:in_reply_to_id])
	\|> put_application(conn)

	attrs = %{
	params: Map.new(params, fn {key, value} -> {to_string(key), value} end),
	scheduled_at: scheduled_at
	}

	with {:far_enough, true} <- {:far_enough, ScheduledActivity.far_enough?(scheduled_at)},
	{:ok, scheduled_activity} <- ScheduledActivity.create(user, attrs) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", scheduled_activity: scheduled_activity)
	else
	{:far_enough, _} ->
	params = Map.drop(params, [:scheduled_at])

	put_in(
	conn,
	[Access.key(:private), Access.key(:open_api_spex), Access.key(:body_params)],
	params
	)
	\|> do_create

	error ->
	error
	end
	end

	# Creates a regular status
	def create(
	%{
	private: %{open_api_spex: %{body_params: %{status: _}}}
	} = conn,
	_
	) do
	do_create(conn)
	end

	def create(
	%{
	assigns: %{user: _user},
	private: %{open_api_spex: %{body_params: %{media_ids: _} = params}}
	} = conn,
	_
	) do
	params = Map.put(params, :status, "")

	put_in(
	conn,
	[Access.key(:private), Access.key(:open_api_spex), Access.key(:body_params)],
	params
	)
	\|> do_create
	end

	defp do_create(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: params}}} = conn
	) do
	params =
	Map.put(params, :in_reply_to_status_id, params[:in_reply_to_id])
	\|> put_application(conn)

	with {:ok, activity} <- CommonAPI.post(user, params) do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	as: :activity,
	with_direct_conversation_id: true
	)
	else
	{:error, {:reject, message}} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})

	{:error, message} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})
	end
	end

	@doc "GET /api/v1/statuses/:id/history"
	def show_history(
	%{assigns: assigns, private: %{open_api_spex: %{params: %{id: id} = params}}} = conn,
	_
	) do
	with user = assigns[:user],
	%Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	try_render(conn, "history.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	_ -> {:error, :not_found}
	end
	end

	@doc "GET /api/v1/statuses/:id/source"
	def show_source(%{assigns: assigns, private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	with user = assigns[:user],
	%Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	try_render(conn, "source.json",
	activity: activity,
	for: user
	)
	else
	_ -> {:error, :not_found}
	end
	end

	@doc "PUT /api/v1/statuses/:id"
	def update(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: body_params, params: %{id: id} = params}}
	} = conn,
	_
	) do
	with {_, %Activity{}} = {_, activity} <- {:activity, Activity.get_by_id_with_object(id)},
	{_, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
	{_, true} <- {:is_create, activity.data["type"] == "Create"},
	actor <- Activity.user_actor(activity),
	{_, true} <- {:own_status, actor.id == user.id},
	changes <- body_params \|> put_application(conn),
	{_, {:ok, _update_activity}} <- {:pipeline, CommonAPI.update(activity, user, changes)},
	{_, %Activity{}} = {_, activity} <- {:refetched, Activity.get_by_id_with_object(id)} do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	{:own_status, _} -> {:error, :forbidden}
	{:pipeline, _} -> {:error, :internal_server_error}
	_ -> {:error, :not_found}
	end
	end

	@doc "GET /api/v1/statuses/:id"
	def show(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id} = params}}} =
	conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	_ -> {:error, :not_found}
	end
	end

	@doc "DELETE /api/v1/statuses/:id"
	def delete(%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	{:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	try_render(conn, "show.json",
	activity: activity,
	for: user,
	with_direct_conversation_id: true,
	with_source: true
	)
	else
	_e -> {:error, :not_found}
	end
	end

	@doc "POST /api/v1/statuses/:id/reblog"
	def reblog(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: params, params: %{id: ap_id_or_id}}}
	} = conn,
	_
	) do
	with {:ok, announce} <- CommonAPI.repeat(ap_id_or_id, user, params),
	%Activity{} = announce <- Activity.normalize(announce.data) do
	try_render(conn, "show.json", %{activity: announce, for: user, as: :activity})
	end
	end

	@doc "POST /api/v1/statuses/:id/unreblog"
	def unreblog(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: activity_id}}}} =
	conn,
	_
	) do
	with {:ok, _unannounce} <- CommonAPI.unrepeat(activity_id, user),
	%Activity{} = activity <- Activity.get_by_id(activity_id) do
	try_render(conn, "show.json", %{activity: activity, for: user, as: :activity})
	end
	end

	@doc "POST /api/v1/statuses/:id/favourite"
	def favourite(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: activity_id}}}} =
	conn,
	_
	) do
	with {:ok, _fav} <- CommonAPI.favorite(activity_id, user),
	%Activity{} = activity <- Activity.get_by_id(activity_id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/unfavourite"
	def unfavourite(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: activity_id}}}} =
	conn,
	_
	) do
	with {:ok, _unfav} <- CommonAPI.unfavorite(activity_id, user),
	%Activity{} = activity <- Activity.get_by_id(activity_id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/pin"
	def pin(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: ap_id_or_id}}}} =
	conn,
	_
	) do
	with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	else
	{:error, :pinned_statuses_limit_reached} ->
	{:error, "You have already pinned the maximum number of statuses"}

	{:error, :ownership_error} ->
	{:error, :unprocessable_entity, "Someone else's status cannot be pinned"}

	{:error, :visibility_error} ->
	{:error, :unprocessable_entity, "Non-public status cannot be pinned"}

	error ->
	error
	end
	end

	@doc "POST /api/v1/statuses/:id/unpin"
	def unpin(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: ap_id_or_id}}}} =
	conn,
	_
	) do
	with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/bookmark"
	def bookmark(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: body_params, params: %{id: id}}}
	} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	folder_id <- Map.get(body_params, :folder_id, nil),
	folder_id <-
	if(folder_id && BookmarkFolder.belongs_to_user?(folder_id, user.id),
	do: folder_id,
	else: nil
	),
	{:ok, _bookmark} <- Bookmark.create(user.id, activity.id, folder_id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/unbookmark"
	def unbookmark(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, _bookmark} <- Bookmark.destroy(user.id, activity.id) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/mute"
	def mute_conversation(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: params, params: %{id: id}}}
	} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	{:ok, activity} <- CommonAPI.add_mute(activity, user, params) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "POST /api/v1/statuses/:id/unmute"
	def unmute_conversation(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{params: %{id: id}}}
	} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	{:ok, activity} <- CommonAPI.remove_mute(activity, user) do
	try_render(conn, "show.json", activity: activity, for: user, as: :activity)
	end
	end

	@doc "GET /api/v1/statuses/:id/favourited_by"
	def favourited_by(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) do
	with true <- Pleroma.Config.get([:instance, :show_reactions]),
	%Activity{} = activity <- Activity.get_by_id_with_object(id),
	{:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
	%Object{data: %{"likes" => likes}} <- Object.normalize(activity, fetch: false) do
	users =
	User
	\|> Ecto.Query.where([u], u.ap_id in ^likes)
	\|> Repo.all()
	\|> Enum.filter(&(not User.blocks?(user, &1)))

	conn
	\|> put_view(AccountView)
	\|> render("index.json", for: user, users: users, as: :user)
	else
	{:visible, false} -> {:error, :not_found}
	_ -> json(conn, [])
	end
	end

	@doc "GET /api/v1/statuses/:id/reblogged_by"
	def reblogged_by(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	{:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
	%Object{data: %{"announcements" => announces, "id" => ap_id}} <-
	Object.normalize(activity, fetch: false) do
	announces =
	"Announce"
	\|> Activity.Queries.by_type()
	\|> Ecto.Query.where([a], a.actor in ^announces)
	# this is to use the index
	\|> Activity.Queries.by_object_id(ap_id)
	\|> Repo.all()
	\|> Enum.filter(&Visibility.visible_for_user?(&1, user))
	\|> Enum.map(& &1.actor)
	\|> Enum.uniq()

	users =
	User
	\|> Ecto.Query.where([u], u.ap_id in ^announces)
	\|> Repo.all()
	\|> Enum.filter(&(not User.blocks?(user, &1)))

	conn
	\|> put_view(AccountView)
	\|> render("index.json", for: user, users: users, as: :user)
	else
	{:visible, false} -> {:error, :not_found}
	_ -> json(conn, [])
	end
	end

	@doc "GET /api/v1/statuses/:id/context"
	def context(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) do
	with %Activity{} = activity <- Activity.get_by_id(id) do
	activities =
	ActivityPub.fetch_activities_for_context(activity.data["context"], %{
	blocking_user: user,
	user: user,
	exclude_id: activity.id
	})

	render(conn, "context.json", activity: activity, activities: activities, user: user)
	end
	end

	@doc "POST /api/v1/statuses/:id/translate"
	def translate(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: params, params: %{id: status_id}}}
	} = conn,
	_
	) do
	with %Activity{object: object} <- Activity.get_by_id_with_object(status_id),
	{:visibility, visibility} when visibility in ["public", "unlisted"] <-
	{:visibility, Visibility.get_visibility(object)},
	{:language, language} when is_binary(language) <-
	{:language, Map.get(params, :lang) \|\| user.language},
	{:ok, result} <-
	Translation.translate(
	object.data["content"],
	object.data["language"],
	language
	) do
	render(conn, "translation.json", result)
	else
	{:language, nil} ->
	render_error(conn, :bad_request, "Language not specified")

	{:visibility, _} ->
	render_error(conn, :not_found, "Record not found")

	{:error, :not_found} ->
	render_error(conn, :not_found, "Translation service not configured")

	{:error, error} when error in [:unexpected_response, :quota_exceeded, :too_many_requests] ->
	render_error(conn, :service_unavailable, "Translation service not available")
	+
	+ _ ->
	+ render_error(conn, :internal_server_error, "Translation failed")
	end
	end

	@doc "GET /api/v1/favourites"
	def favourites(
	%{assigns: %{user: %User{} = user}, private: %{open_api_spex: %{params: params}}} = conn,
	_
	) do
	activities = ActivityPub.fetch_favourites(user, params)

	conn
	\|> add_link_headers(activities)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity
	)
	end

	@doc "GET /api/v1/bookmarks"
	def bookmarks(%{assigns: %{user: user}, private: %{open_api_spex: %{params: params}}} = conn, _) do
	user = User.get_cached_by_id(user.id)
	folder_id = Map.get(params, :folder_id)

	bookmarks =
	user.id
	\|> Bookmark.for_user_query(folder_id)
	\|> Pleroma.Pagination.fetch_paginated(params)

	activities =
	bookmarks
	\|> Enum.map(fn b -> Map.put(b.activity, :bookmark, Map.delete(b, :activity)) end)

	conn
	\|> add_link_headers(bookmarks)
	\|> render("index.json",
	activities: activities,
	for: user,
	as: :activity
	)
	end

	defp put_application(params, %{assigns: %{token: %Token{user: %User{} = user} = token}} = _conn) do
	if user.disclose_client do
	%{client_name: client_name, website: website} = Repo.preload(token, :app).app
	Map.put(params, :generator, %{type: "Application", name: client_name, url: website})
	else
	Map.put(params, :generator, nil)
	end
	end

	defp put_application(params, _), do: Map.put(params, :generator, nil)
	end
	diff --git a/test/mix/tasks/pleroma/app_test.exs b/test/mix/tasks/pleroma/app_test.exs
	index f35447edc..65245eadd 100644
	--- a/test/mix/tasks/pleroma/app_test.exs
	+++ b/test/mix/tasks/pleroma/app_test.exs
	@@ -1,65 +1,66 @@
	# 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.AppTest do
	use Pleroma.DataCase, async: true

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)
	end

	describe "creates new app" do
	test "with default scopes" do
	name = "Some name"
	redirect = "https://example.com"
	Mix.Tasks.Pleroma.App.run(["create", "-n", name, "-r", redirect])

	assert_app(name, redirect, ["read", "write", "follow", "push"])
	end

	test "with custom scopes" do
	name = "Another name"
	redirect = "https://example.com"

	Mix.Tasks.Pleroma.App.run([
	"create",
	"-n",
	name,
	"-r",
	redirect,
	"-s",
	"read,write,follow,push,admin"
	])

	assert_app(name, redirect, ["read", "write", "follow", "push", "admin"])
	end
	end

	test "with errors" do
	Mix.Tasks.Pleroma.App.run(["create"])
	- {:mix_shell, :error, ["Creating failed:"]}
	- {:mix_shell, :error, ["name: can't be blank"]}
	- {:mix_shell, :error, ["redirect_uris: can't be blank"]}
	+
	+ assert_receive {:mix_shell, :error, ["Creating failed:"]}
	+ assert_receive {:mix_shell, :error, ["name: can't be blank"]}
	+ assert_receive {:mix_shell, :error, ["redirect_uris: can't be blank"]}
	end

	defp assert_app(name, redirect, scopes) do
	app = Repo.get_by(Pleroma.Web.OAuth.App, client_name: name)

	assert_receive {:mix_shell, :info, [message]}
	assert message == "#{name} successfully created:"

	assert_receive {:mix_shell, :info, [message]}
	assert message == "App client_id: #{app.client_id}"

	assert_receive {:mix_shell, :info, [message]}
	assert message == "App client_secret: #{app.client_secret}"

	assert app.scopes == scopes
	assert app.redirect_uris == redirect
	end
	end
	diff --git a/test/pleroma/emoji/pack_test.exs b/test/pleroma/emoji/pack_test.exs
	index b458401a7..56b17ac31 100644
	--- a/test/pleroma/emoji/pack_test.exs
	+++ b/test/pleroma/emoji/pack_test.exs
	@@ -1,155 +1,158 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji.PackTest do
	use Pleroma.DataCase
	alias Pleroma.Emoji
	alias Pleroma.Emoji.Pack

	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)

	setup do
	+ # Reload emoji to ensure a clean state
	+ Emoji.reload()
	+
	pack_path = Path.join(@emoji_path, "dump_pack")
	File.mkdir(pack_path)

	File.write!(Path.join(pack_path, "pack.json"), """
	{
	"files": { },
	"pack": {
	"description": "Dump pack", "homepage": "https://pleroma.social",
	"license": "Test license", "share-files": true
	}}
	""")

	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("dump_pack")

	on_exit(fn ->
	File.rm_rf!(pack_path)
	end)

	{:ok, pack: pack}
	end

	describe "add_file/4" do
	test "add emojies from zip file", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/emojis.zip")
	}

	{:ok, updated_pack} = Pack.add_file(pack, nil, nil, file)

	assert updated_pack.files == %{
	"a_trusted_friend-128" => "128px/a_trusted_friend-128.png",
	"auroraborealis" => "auroraborealis.png",
	"baby_in_a_box" => "1000px/baby_in_a_box.png",
	"bear" => "1000px/bear.png",
	"bear-128" => "128px/bear-128.png"
	}

	assert updated_pack.files_count == 5
	end

	test "skips existing emojis when adding from zip file", %{pack: pack} do
	# First, let's create a test pack with a "bear" emoji
	test_pack_path = Path.join(@emoji_path, "test_bear_pack")
	Pleroma.Backports.mkdir_p(test_pack_path)

	# Create a pack.json file
	File.write!(Path.join(test_pack_path, "pack.json"), """
	{
	"files": { "bear": "bear.png" },
	"pack": {
	"description": "Bear Pack", "homepage": "https://pleroma.social",
	"license": "Test license", "share-files": true
	}}
	""")

	# Copy a test image to use as the bear emoji
	File.cp!(
	Path.absname("test/instance_static/emoji/test_pack/blank.png"),
	Path.join(test_pack_path, "bear.png")
	)

	# Load the pack to register the "bear" emoji in the global registry
	{:ok, _bear_pack} = Pleroma.Emoji.Pack.load_pack("test_bear_pack")

	# Reload emoji to make sure the bear emoji is in the global registry
	Emoji.reload()

	# Verify that the bear emoji exists in the global registry
	assert Emoji.exist?("bear")

	# Now try to add a zip file that contains an emoji with the same shortcode
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/emojis.zip")
	}

	{:ok, updated_pack} = Pack.add_file(pack, nil, nil, file)

	# Verify that the "bear" emoji was skipped
	refute Map.has_key?(updated_pack.files, "bear")

	# Other emojis should be added
	assert Map.has_key?(updated_pack.files, "a_trusted_friend-128")
	assert Map.has_key?(updated_pack.files, "auroraborealis")
	assert Map.has_key?(updated_pack.files, "baby_in_a_box")
	assert Map.has_key?(updated_pack.files, "bear-128")

	# Total count should be 4 (all emojis except "bear")
	assert updated_pack.files_count == 4

	# Clean up the test pack
	on_exit(fn ->
	File.rm_rf!(test_pack_path)
	end)
	end
	end

	test "returns error when zip file is bad", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/instance_static/emoji/test_pack/blank.png")
	}

	assert {:error, _} = Pack.add_file(pack, nil, nil, file)
	end

	test "returns pack when zip file is empty", %{pack: pack} do
	file = %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/empty.zip")
	}

	{:ok, updated_pack} = Pack.add_file(pack, nil, nil, file)
	assert updated_pack == pack
	end

	test "add emoji file", %{pack: pack} do
	file = %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}

	{:ok, updated_pack} = Pack.add_file(pack, "test_blank", "test_blank.png", file)

	assert updated_pack.files == %{
	"test_blank" => "test_blank.png"
	}

	assert updated_pack.files_count == 1
	end

	test "load_pack/1 ignores path traversal in a forged pack name", %{pack: pack} do
	assert {:ok, ^pack} = Pack.load_pack("../../../../../dump_pack")
	end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/account_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/account_controller_test.exs
	index 61880e2c0..d152a44cd 100644
	--- a/test/pleroma/web/pleroma_api/controllers/account_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/account_controller_test.exs
	@@ -1,362 +1,366 @@
	# 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.AccountControllerTest do
	use Pleroma.Web.ConnCase

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

	import Pleroma.Factory
	import Swoosh.TestAssertions

	describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
	setup do
	{:ok, user} =
	insert(:user)
	\|> User.confirmation_changeset(set_confirmation: false)
	\|> User.update_and_set_cache()

	refute user.is_confirmed

	[user: user]
	end

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

	test "resend account confirmation email", %{conn: conn, user: user} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/accounts/confirmation_resend?email=#{user.email}")
	\|> json_response_and_validate_schema(:no_content)

	ObanHelpers.perform_all()

	email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
	notify_email = Config.get([:instance, :notify_email])
	instance_name = Config.get([:instance, :name])

	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "resend account confirmation email (with nickname)", %{conn: conn, user: user} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/accounts/confirmation_resend?nickname=#{user.nickname}")
	\|> json_response_and_validate_schema(:no_content)

	ObanHelpers.perform_all()

	email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
	notify_email = Config.get([:instance, :notify_email])
	instance_name = Config.get([:instance, :name])

	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end
	end

	describe "getting favorites timeline of specified user" do
	setup do
	[current_user, user] = insert_pair(:user, hide_favorites: false)
	%{user: current_user, conn: conn} = oauth_access(["read:favourites"], user: current_user)
	[current_user: current_user, user: user, conn: conn]
	end

	test "returns list of statuses favorited by specified user", %{
	conn: conn,
	user: user
	} do
	[activity \| _] = insert_pair(:note_activity)
	CommonAPI.favorite(activity.id, user)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(:ok)

	[like] = response

	assert length(response) == 1
	assert like["id"] == activity.id
	end

	test "returns favorites for specified user_id when requester is not logged in", %{
	user: user
	} do
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	response =
	build_conn()
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 1
	end

	test "returns favorited DM only when user is logged in and he is one of recipients", %{
	current_user: current_user,
	user: user
	} do
	{:ok, direct} =
	CommonAPI.post(current_user, %{
	status: "Hi @#{user.nickname}!",
	visibility: "direct"
	})

	CommonAPI.favorite(direct.id, user)

	for u <- [user, current_user] do
	response =
	build_conn()
	\|> assign(:user, u)
	\|> assign(:token, insert(:oauth_token, user: u, scopes: ["read:favourites"]))
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(:ok)

	assert length(response) == 1
	end

	response =
	build_conn()
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 0
	end

	test "does not return others' favorited DM when user is not one of recipients", %{
	conn: conn,
	user: user
	} do
	user_two = insert(:user)

	{:ok, direct} =
	CommonAPI.post(user_two, %{
	status: "Hi @#{user.nickname}!",
	visibility: "direct"
	})

	CommonAPI.favorite(direct.id, user)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "paginates favorites using since_id and max_id", %{
	conn: conn,
	user: user
	} do
	activities = insert_list(10, :note_activity)

	Enum.each(activities, fn activity ->
	CommonAPI.favorite(activity.id, user)
	end)

	third_activity = Enum.at(activities, 2)
	seventh_activity = Enum.at(activities, 6)

	response =
	conn
	\|> get(
	"/api/v1/pleroma/accounts/#{user.id}/favourites?since_id=#{third_activity.id}&max_id=#{seventh_activity.id}"
	)
	\|> json_response_and_validate_schema(:ok)

	assert length(response) == 3
	refute third_activity in response
	refute seventh_activity in response
	end

	test "limits favorites using limit parameter", %{
	conn: conn,
	user: user
	} do
	7
	\|> insert_list(:note_activity)
	\|> Enum.each(fn activity ->
	CommonAPI.favorite(activity.id, user)
	end)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites?limit=3")
	\|> json_response_and_validate_schema(:ok)

	assert length(response) == 3
	end

	test "returns empty response when user does not have any favorited statuses", %{
	conn: conn,
	user: user
	} do
	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "returns 404 error when specified user is not exist", %{conn: conn} do
	conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end

	test "returns 403 error when user has hidden own favorites", %{conn: conn} do
	user = insert(:user, hide_favorites: true)
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/favourites")

	assert json_response_and_validate_schema(conn, 403) == %{"error" => "Can't get favorites"}
	end

	test "hides favorites for new users by default", %{conn: conn} do
	user = insert(:user)
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	assert user.hide_favorites
	conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/favourites")

	assert json_response_and_validate_schema(conn, 403) == %{"error" => "Can't get favorites"}
	end
	end

	describe "subscribing / unsubscribing" do
	test "subscribing / unsubscribing to a user" do
	%{user: user, conn: conn} = oauth_access(["follow"])
	subscription_target = insert(:user)

	ret_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")

	assert %{"id" => _id, "subscribing" => true} =
	json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")

	assert %{"id" => _id, "subscribing" => false} = json_response_and_validate_schema(conn, 200)
	end
	end

	describe "subscribing" do
	test "returns 404 when subscription_target not found" do
	%{conn: conn} = oauth_access(["write:follows"])

	conn = post(conn, "/api/v1/pleroma/accounts/target_id/subscribe")

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
	end
	end

	describe "unsubscribing" do
	test "returns 404 when subscription_target not found" do
	%{conn: conn} = oauth_access(["follow"])

	conn = post(conn, "/api/v1/pleroma/accounts/target_id/unsubscribe")

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
	end
	end

	describe "account endorsements" do
	test "returns a list of pinned accounts", %{conn: conn} do
	%{id: id1} = user1 = insert(:user)
	%{id: id2} = user2 = insert(:user)
	%{id: id3} = user3 = insert(:user)

	CommonAPI.follow(user2, user1)
	CommonAPI.follow(user3, user1)

	User.endorse(user1, user2)
	User.endorse(user1, user3)

	- [%{"id" => ^id2}, %{"id" => ^id3}] =
	+ response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{id1}/endorsements")
	\|> json_response_and_validate_schema(200)
	+
	+ assert length(response) == 2
	+ assert Enum.any?(response, fn user -> user["id"] == id2 end)
	+ assert Enum.any?(response, fn user -> user["id"] == id3 end)
	end

	test "returns 404 error when specified user is not exist", %{conn: conn} do
	conn = get(conn, "/api/v1/pleroma/accounts/test/endorsements")

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end
	end

	describe "birthday reminders" do
	test "returns a list of friends having birthday on specified day" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	%{id: id1} =
	user1 =
	insert(:user, %{
	birthday: "2001-02-12",
	show_birthday: true
	})

	user2 =
	insert(:user, %{
	birthday: "2001-02-14",
	show_birthday: true
	})

	user3 = insert(:user)

	CommonAPI.follow(user1, user)
	CommonAPI.follow(user2, user)
	CommonAPI.follow(user3, user)

	[%{"id" => ^id1}] =
	conn
	\|> get("/api/v1/pleroma/birthdays?day=12&month=2")
	\|> json_response_and_validate_schema(:ok)
	end

	test "the list doesn't list friends with hidden birth date" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	user1 =
	insert(:user, %{
	birthday: "2001-02-12",
	show_birthday: false
	})

	%{id: id2} =
	user2 =
	insert(:user, %{
	birthday: "2001-02-12",
	show_birthday: true
	})

	CommonAPI.follow(user1, user)
	CommonAPI.follow(user2, user)

	[%{"id" => ^id2}] =
	conn
	\|> get("/api/v1/pleroma/birthdays?day=12&month=2")
	\|> json_response_and_validate_schema(:ok)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 31, 12:15 AM (19 h, 2 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1800795
Default Alt Text: (72 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions