No OneTemporary
Actions

Size

32 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/search.ex b/lib/pleroma/search.ex
	index fd0218cb8..b9d2a0188 100644
	--- a/lib/pleroma/search.ex
	+++ b/lib/pleroma/search.ex
	@@ -1,21 +1,21 @@
	defmodule Pleroma.Search do
	alias Pleroma.Workers.SearchIndexingWorker

	def add_to_index(%Pleroma.Activity{id: activity_id}) do
	SearchIndexingWorker.enqueue("add_to_index", %{"activity" => activity_id})
	end

	def remove_from_index(%Pleroma.Object{id: object_id}) do
	SearchIndexingWorker.enqueue("remove_from_index", %{"object" => object_id})
	end

	def search(query, options) do
	search_module = Pleroma.Config.get([Pleroma.Search, :module])
	search_module.search(options[:for_user], query, options)
	end

	def healthcheck_endpoints do
	search_module = Pleroma.Config.get([Pleroma.Search, :module])
	- search_module.healthcheck_endpoints
	+ search_module.healthcheck_endpoints()
	end
	end
	diff --git a/lib/pleroma/web.ex b/lib/pleroma/web.ex
	index 7a8b176cd..e7e7e96f9 100644
	--- a/lib/pleroma/web.ex
	+++ b/lib/pleroma/web.ex
	@@ -1,242 +1,242 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	This can be used in your application as:

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

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

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

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

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

	import Plug.Conn

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

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

	plug(:set_put_layout)

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

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

	defp skip_auth(conn, _) do
	skip_plug(conn, [OAuthScopesPlug, EnsurePublicOrAuthenticatedPlug])
	end

	defp skip_public_check(conn, _) do
	skip_plug(conn, EnsurePublicOrAuthenticatedPlug)
	end

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

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

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

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

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

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

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

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

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

	require Logger

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

	nil
	end

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

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

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

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

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

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

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

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

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

	defmodule Pleroma.Web.ActivityPub.MRF do
	require Logger

	@behaviour Pleroma.Web.ActivityPub.MRF.PipelineFiltering

	@mrf_config_descriptions [
	%{
	group: :pleroma,
	key: :mrf,
	tab: :mrf,
	label: "MRF",
	type: :group,
	description: "General MRF settings",
	children: [
	%{
	key: :policies,
	type: [:module, {:list, :module}],
	description:
	"A list of MRF policies enabled. Module names are shortened (removed leading `Pleroma.Web.ActivityPub.MRF.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Web.ActivityPub.MRF.Policy}
	},
	%{
	key: :transparency,
	label: "MRF transparency",
	type: :boolean,
	description:
	"Make the content of your Message Rewrite Facility settings public (via nodeinfo)"
	},
	%{
	key: :transparency_exclusions,
	label: "MRF transparency exclusions",
	type: {:list, :tuple},
	key_placeholder: "instance",
	value_placeholder: "reason",
	description:
	"Exclude specific instance names from MRF transparency. The use of the exclusions feature will be disclosed in nodeinfo as a boolean value. You can also provide a reason for excluding these instance names. The instances and reasons won't be publicly disclosed.",
	suggestions: [
	"exclusion.com"
	]
	}
	]
	}
	]

	@default_description %{
	label: "",
	description: ""
	}

	@required_description_keys [:key, :related_policy]

	def filter_one(policy, message) do
	Code.ensure_loaded(policy)

	should_plug_history? =
	if function_exported?(policy, :history_awareness, 0) do
	policy.history_awareness()
	else
	:manual
	end
	\|> Kernel.==(:auto)

	if not should_plug_history? do
	policy.filter(message)
	else
	main_result = policy.filter(message)

	with {_, {:ok, main_message}} <- {:main, main_result},
	{_,
	%{
	"formerRepresentations" => %{
	"orderedItems" => [_ \| _]
	}
	}} = {_, object} <- {:object, message["object"]},
	{_, {:ok, new_history}} <-
	{:history,
	Pleroma.Object.Updater.for_each_history_item(
	object["formerRepresentations"],
	object,
	fn item ->
	with {:ok, filtered} <- policy.filter(Map.put(message, "object", item)) do
	{:ok, filtered["object"]}
	else
	e -> e
	end
	end
	)} do
	{:ok, put_in(main_message, ["object", "formerRepresentations"], new_history)}
	else
	{:main, _} -> main_result
	{:object, _} -> main_result
	{:history, e} -> e
	end
	end
	end

	def filter(policies, %{} = message) do
	policies
	\|> Enum.reduce({:ok, message}, fn
	policy, {:ok, message} -> filter_one(policy, message)
	_, error -> error
	end)
	end

	def filter(%{} = object), do: get_policies() \|> filter(object)

	@impl true
	def pipeline_filter(%{} = message, meta) do
	object = meta[:object_data]
	ap_id = message["object"]

	if object && ap_id do
	with {:ok, message} <- filter(Map.put(message, "object", object)) do
	meta = Keyword.put(meta, :object_data, message["object"])
	{:ok, Map.put(message, "object", ap_id), meta}
	else
	{err, message} -> {err, message, meta}
	end
	else
	{err, message} = filter(message)

	{err, message, meta}
	end
	end

	def get_policies do
	Pleroma.Config.get([:mrf, :policies], [])
	\|> get_policies()
	\|> Enum.concat([Pleroma.Web.ActivityPub.MRF.HashtagPolicy])
	end

	defp get_policies(policy) when is_atom(policy), do: [policy]
	defp get_policies(policies) when is_list(policies), do: policies
	defp get_policies(_), do: []

	@spec subdomains_regex([String.t()]) :: [Regex.t()]
	def subdomains_regex(domains) when is_list(domains) do
	for domain <- domains do
	try do
	target = String.replace(domain, ".", "(.\\.)*")
	~r<^#{target}$>i
	rescue
	e ->
	Logger.error("MRF: Invalid subdomain Regex: #{domain}")
	reraise e, __STACKTRACE__
	end
	end
	end

	@spec subdomain_match?([Regex.t()], String.t()) :: boolean()
	def subdomain_match?(domains, host) do
	Enum.any?(domains, fn domain -> Regex.match?(domain, host) end)
	end

	@spec instance_list_from_tuples([{String.t(), String.t()}]) :: [String.t()]
	def instance_list_from_tuples(list) do
	Enum.map(list, fn {instance, _} -> instance end)
	end

	def describe(policies) do
	{:ok, policy_configs} =
	policies
	\|> Enum.reduce({:ok, %{}}, fn
	policy, {:ok, data} ->
	{:ok, policy_data} = policy.describe()
	{:ok, Map.merge(data, policy_data)}

	_, error ->
	error
	end)

	mrf_policies =
	get_policies()
	\|> Enum.map(fn policy -> to_string(policy) \|> String.split(".") \|> List.last() end)

	exclusions = Pleroma.Config.get([:mrf, :transparency_exclusions])

	base =
	%{
	mrf_policies: mrf_policies,
	exclusions: length(exclusions) > 0
	}
	\|> Map.merge(policy_configs)

	{:ok, base}
	end

	def describe, do: get_policies() \|> describe()

	def config_descriptions do
	Pleroma.Web.ActivityPub.MRF.Policy
	\|> Pleroma.Docs.Generator.list_behaviour_implementations()
	\|> config_descriptions()
	end

	def config_descriptions(policies) do
	Enum.reduce(policies, @mrf_config_descriptions, fn policy, acc ->
	Code.ensure_loaded(policy)

	if function_exported?(policy, :config_description, 0) do
	description =
	@default_description
	- \|> Map.merge(policy.config_description)
	+ \|> Map.merge(policy.config_description())
	\|> Map.put(:group, :pleroma)
	\|> Map.put(:tab, :mrf)
	\|> Map.put(:type, :group)

	if Enum.all?(@required_description_keys, &Map.has_key?(description, &1)) do
	[description \| acc]
	else
	Logger.warning(
	"#{policy} config description doesn't have one or all required keys #{inspect(@required_description_keys)}"
	)

	acc
	end
	else
	Logger.debug(
	"#{policy} is excluded from config descriptions, because does not implement `config_description/0` method."
	)

	acc
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/streaming_operation.ex b/lib/pleroma/web/api_spec/operations/streaming_operation.ex
	index b580bc2f0..47bce07b3 100644
	--- a/lib/pleroma/web/api_spec/operations/streaming_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/streaming_operation.ex
	@@ -1,464 +1,464 @@
	# 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.StreamingOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Response
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.NotificationOperation
	alias Pleroma.Web.ApiSpec.Schemas.Chat
	alias Pleroma.Web.ApiSpec.Schemas.Conversation
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.Schemas.Status

	require Pleroma.Constants

	@spec open_api_operation(atom) :: Operation.t()
	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	@spec streaming_operation() :: Operation.t()
	def streaming_operation do
	%Operation{
	tags: ["Timelines"],
	summary: "Establish streaming connection",
	description: """
	Receive statuses in real-time via WebSocket.

	You can specify the access token on the query string or through the `sec-websocket-protocol` header. Using
	the query string to authenticate is considered unsafe and should not be used unless you have to (e.g. to maintain
	your client's compatibility with Mastodon).

	You may specify a stream on the query string. If you do so and you are connecting to a stream that requires logged-in users,
	you must specify the access token at the time of the connection (i.e. via query string or header).

	Otherwise, you have the option to authenticate after you have established the connection through client-sent events.

	The "Request body" section below describes what events clients can send through WebSocket, and the "Responses" section
	describes what events server will send through WebSocket.
	""",
	security: [%{"oAuth" => ["read:statuses", "read:notifications"]}],
	operationId: "WebsocketHandler.streaming",
	parameters:
	[
	Operation.parameter(:connection, :header, %Schema{type: :string}, "connection header",
	required: true
	),
	Operation.parameter(:upgrade, :header, %Schema{type: :string}, "upgrade header",
	required: true
	),
	Operation.parameter(
	:"sec-websocket-key",
	:header,
	%Schema{type: :string},
	"sec-websocket-key header",
	required: true
	),
	Operation.parameter(
	:"sec-websocket-version",
	:header,
	%Schema{type: :string},
	"sec-websocket-version header",
	required: true
	)
	] ++ stream_params() ++ access_token_params(),
	requestBody: request_body("Client-sent events", client_sent_events()),
	responses: %{
	101 => switching_protocols_response(),
	200 =>
	Operation.response(
	"Server-sent events",
	"application/json",
	server_sent_events()
	)
	}
	}
	end

	defp stream_params do
	stream_specifier()
	\|> Enum.map(fn {name, schema} ->
	Operation.parameter(name, :query, schema, get_schema(schema).description)
	end)
	end

	defp access_token_params do
	[
	Operation.parameter(:access_token, :query, token(), token().description),
	Operation.parameter(:"sec-websocket-protocol", :header, token(), token().description)
	]
	end

	defp switching_protocols_response do
	%Response{
	description: "Switching protocols",
	headers: %{
	"connection" => %OpenApiSpex.Header{required: true},
	"upgrade" => %OpenApiSpex.Header{required: true},
	"sec-websocket-accept" => %OpenApiSpex.Header{required: true}
	}
	}
	end

	defp server_sent_events do
	%Schema{
	oneOf: [
	update_event(),
	status_update_event(),
	notification_event(),
	chat_update_event(),
	follow_relationships_update_event(),
	conversation_event(),
	delete_event(),
	pleroma_respond_event()
	]
	}
	end

	defp stream do
	%Schema{
	type: :array,
	title: "Stream",
	description: """
	The stream identifier.
	The first item is the name of the stream. If the stream needs a differentiator, the second item will be the corresponding identifier.
	Currently, for the following stream types, there is a second element in the array:

	- `list`: The second element is the id of the list, as a string.
	- `hashtag`: The second element is the name of the hashtag.
	- `public:remote:media` and `public:remote`: The second element is the domain of the corresponding instance.
	""",
	maxItems: 2,
	minItems: 1,
	items: %Schema{type: :string},
	example: ["hashtag", "mew"]
	}
	end

	defp get_schema(%Schema{} = schema), do: schema
	- defp get_schema(schema), do: schema.schema
	+ defp get_schema(schema), do: schema.schema()

	defp server_sent_event_helper(name, description, type, payload, opts \\ []) do
	payload_type = Keyword.get(opts, :payload_type, :json)
	has_stream = Keyword.get(opts, :has_stream, true)

	stream_properties =
	if has_stream do
	%{stream: stream()}
	else
	%{}
	end

	stream_example = if has_stream, do: %{"stream" => get_schema(stream()).example}, else: %{}

	stream_required = if has_stream, do: [:stream], else: []

	payload_schema =
	if payload_type == :json do
	%Schema{
	title: "Event payload",
	description: "JSON-encoded string of #{get_schema(payload).title}",
	allOf: [payload]
	}
	else
	payload
	end

	payload_example =
	if payload_type == :json do
	get_schema(payload).example \|> Jason.encode!()
	else
	get_schema(payload).example
	end

	%Schema{
	type: :object,
	title: name,
	description: description,
	required: [:event, :payload] ++ stream_required,
	properties:
	%{
	event: %Schema{
	title: "Event type",
	description: "Type of the event.",
	type: :string,
	required: true,
	enum: [type]
	},
	payload: payload_schema
	}
	\|> Map.merge(stream_properties),
	example:
	%{
	"event" => type,
	"payload" => payload_example
	}
	\|> Map.merge(stream_example)
	}
	end

	defp update_event do
	server_sent_event_helper("New status", "A newly-posted status.", "update", Status)
	end

	defp status_update_event do
	server_sent_event_helper("Edit", "A status that was just edited", "status.update", Status)
	end

	defp notification_event do
	server_sent_event_helper(
	"Notification",
	"A new notification.",
	"notification",
	NotificationOperation.notification()
	)
	end

	defp follow_relationships_update_event do
	server_sent_event_helper(
	"Follow relationships update",
	"An update to follow relationships.",
	"pleroma:follow_relationships_update",
	%Schema{
	type: :object,
	title: "Follow relationships update",
	required: [:state, :follower, :following],
	properties: %{
	state: %Schema{
	type: :string,
	description: "Follow state of the relationship.",
	enum: ["follow_pending", "follow_accept", "follow_reject", "unfollow"]
	},
	follower: %Schema{
	type: :object,
	description: "Information about the follower.",
	required: [:id, :follower_count, :following_count],
	properties: %{
	id: FlakeID,
	follower_count: %Schema{type: :integer},
	following_count: %Schema{type: :integer}
	}
	},
	following: %Schema{
	type: :object,
	description: "Information about the following person.",
	required: [:id, :follower_count, :following_count],
	properties: %{
	id: FlakeID,
	follower_count: %Schema{type: :integer},
	following_count: %Schema{type: :integer}
	}
	}
	},
	example: %{
	"state" => "follow_pending",
	"follower" => %{
	"id" => "someUser1",
	"follower_count" => 1,
	"following_count" => 1
	},
	"following" => %{
	"id" => "someUser2",
	"follower_count" => 1,
	"following_count" => 1
	}
	}
	}
	)
	end

	defp chat_update_event do
	server_sent_event_helper(
	"Chat update",
	"A new chat message.",
	"pleroma:chat_update",
	Chat
	)
	end

	defp conversation_event do
	server_sent_event_helper(
	"Conversation update",
	"An update about a conversation",
	"conversation",
	Conversation
	)
	end

	defp delete_event do
	server_sent_event_helper(
	"Delete",
	"A status that was just deleted.",
	"delete",
	%Schema{
	type: :string,
	title: "Status id",
	description: "Id of the deleted status",
	allOf: [FlakeID],
	example: "some-opaque-id"
	},
	payload_type: :string,
	has_stream: false
	)
	end

	defp pleroma_respond_event do
	server_sent_event_helper(
	"Server response",
	"A response to a client-sent event.",
	"pleroma:respond",
	%Schema{
	type: :object,
	title: "Results",
	required: [:result, :type],
	properties: %{
	result: %Schema{
	type: :string,
	title: "Result of the request",
	enum: ["success", "error", "ignored"]
	},
	error: %Schema{
	type: :string,
	title: "Error code",
	description: "An error identifier. Only appears if `result` is `error`."
	},
	type: %Schema{
	type: :string,
	description: "Type of the request."
	}
	},
	example: %{"result" => "success", "type" => "pleroma:authenticate"}
	},
	has_stream: false
	)
	end

	defp client_sent_events do
	%Schema{
	oneOf: [
	subscribe_event(),
	unsubscribe_event(),
	authenticate_event()
	]
	}
	end

	defp request_body(description, schema, opts \\ []) do
	%OpenApiSpex.RequestBody{
	description: description,
	content: %{
	"application/json" => %OpenApiSpex.MediaType{
	schema: schema,
	example: opts[:example],
	examples: opts[:examples]
	}
	}
	}
	end

	defp client_sent_event_helper(name, description, type, properties, opts) do
	required = opts[:required] \|\| []

	%Schema{
	type: :object,
	title: name,
	required: [:type] ++ required,
	description: description,
	properties:
	%{
	type: %Schema{type: :string, enum: [type], description: "Type of the event."}
	}
	\|> Map.merge(properties),
	example: opts[:example]
	}
	end

	defp subscribe_event do
	client_sent_event_helper(
	"Subscribe",
	"Subscribe to a stream.",
	"subscribe",
	stream_specifier(),
	required: [:stream],
	example: %{"type" => "subscribe", "stream" => "list", "list" => "1"}
	)
	end

	defp unsubscribe_event do
	client_sent_event_helper(
	"Unsubscribe",
	"Unsubscribe from a stream.",
	"unsubscribe",
	stream_specifier(),
	required: [:stream],
	example: %{
	"type" => "unsubscribe",
	"stream" => "public:remote:media",
	"instance" => "example.org"
	}
	)
	end

	defp authenticate_event do
	client_sent_event_helper(
	"Authenticate",
	"Authenticate via an access token.",
	"pleroma:authenticate",
	%{
	token: token()
	},
	required: [:token]
	)
	end

	defp token do
	%Schema{
	type: :string,
	description: "An OAuth access token with corresponding permissions.",
	example: "some token"
	}
	end

	defp stream_specifier do
	%{
	stream: %Schema{
	type: :string,
	description: "The name of the stream.",
	enum:
	Pleroma.Constants.public_streams() ++
	[
	"public:remote",
	"public:remote:media",
	"user",
	"user:pleroma_chat",
	"user:notification",
	"direct",
	"list",
	"hashtag"
	]
	},
	list: %Schema{
	type: :string,
	title: "List id",
	description: "The id of the list. Required when `stream` is `list`.",
	example: "some-id"
	},
	tag: %Schema{
	type: :string,
	title: "Hashtag name",
	description: "The name of the hashtag. Required when `stream` is `hashtag`.",
	example: "mew"
	},
	instance: %Schema{
	type: :string,
	title: "Domain name",
	description:
	"Domain name of the instance. Required when `stream` is `public:remote` or `public:remote:media`.",
	example: "example.org"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/schemas/chat.ex b/lib/pleroma/web/api_spec/schemas/chat.ex
	index a07d12865..affa25a95 100644
	--- a/lib/pleroma/web/api_spec/schemas/chat.ex
	+++ b/lib/pleroma/web/api_spec/schemas/chat.ex
	@@ -1,75 +1,75 @@
	# 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.Schemas.Chat do
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ChatMessage

	require OpenApiSpex

	OpenApiSpex.schema(%{
	title: "Chat",
	description: "Response schema for a Chat",
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	account: %Schema{type: :object},
	unread: %Schema{type: :integer},
	last_message: ChatMessage,
	updated_at: %Schema{type: :string, format: :"date-time"}
	},
	example: %{
	"account" => %{
	"pleroma" => %{
	"is_admin" => false,
	"is_confirmed" => true,
	"hide_followers_count" => false,
	"is_moderator" => false,
	"hide_favorites" => true,
	"ap_id" => "https://dontbulling.me/users/lain",
	"hide_follows_count" => false,
	"hide_follows" => false,
	"background_image" => nil,
	"skip_thread_containment" => false,
	"hide_followers" => false,
	"relationship" => %{},
	"tags" => []
	},
	"avatar" =>
	"https://dontbulling.me/media/065a4dd3c6740dab13ff9c71ec7d240bb9f8be9205c9e7467fb2202117da1e32.jpg",
	"following_count" => 0,
	"header_static" => "https://originalpatchou.li/images/banner.png",
	"source" => %{
	"sensitive" => false,
	"note" => "lain",
	"pleroma" => %{
	"discoverable" => false,
	"actor_type" => "Person"
	},
	"fields" => []
	},
	"statuses_count" => 1,
	"is_locked" => false,
	"created_at" => "2020-04-16T13:40:15.000Z",
	"display_name" => "lain",
	"fields" => [],
	"acct" => "lain@dontbulling.me",
	"id" => "9u6Qw6TAZANpqokMkK",
	"emojis" => [],
	"avatar_static" =>
	"https://dontbulling.me/media/065a4dd3c6740dab13ff9c71ec7d240bb9f8be9205c9e7467fb2202117da1e32.jpg",
	"username" => "lain",
	"followers_count" => 0,
	"header" => "https://originalpatchou.li/images/banner.png",
	"bot" => false,
	"note" => "lain",
	"url" => "https://dontbulling.me/users/lain"
	},
	"id" => "1",
	"unread" => 2,
	- "last_message" => ChatMessage.schema().example(),
	+ "last_message" => ChatMessage.schema().example,
	"updated_at" => "2020-04-21T15:06:45.000Z"
	}
	})
	end

File Metadata

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

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions