No OneTemporary
Actions

Size

29 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/instance-profile-fields.add b/changelog.d/instance-profile-fields.add
	new file mode 100644
	index 000000000..712bd68d9
	--- /dev/null
	+++ b/changelog.d/instance-profile-fields.add
	@@ -0,0 +1 @@
	+Add /api/v2/instance profile fields limits info used by Mastodon
	diff --git a/lib/pleroma/web/api_spec/operations/instance_operation.ex b/lib/pleroma/web/api_spec/operations/instance_operation.ex
	index d8b2901d3..6be4ea996 100644
	--- a/lib/pleroma/web/api_spec/operations/instance_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/instance_operation.ex
	@@ -1,454 +1,466 @@
	# 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.InstanceOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def show_operation do
	%Operation{
	tags: ["Instance misc"],
	summary: "Retrieve instance information",
	description: "Information about the server",
	operationId: "InstanceController.show",
	responses: %{
	200 => Operation.response("Instance", "application/json", instance())
	}
	}
	end

	def show2_operation do
	%Operation{
	tags: ["Instance misc"],
	summary: "Retrieve instance information",
	description: "Information about the server",
	operationId: "InstanceController.show2",
	responses: %{
	200 => Operation.response("Instance", "application/json", instance2())
	}
	}
	end

	def peers_operation do
	%Operation{
	tags: ["Instance misc"],
	summary: "Retrieve list of known instances",
	operationId: "InstanceController.peers",
	responses: %{
	200 => Operation.response("Array of domains", "application/json", array_of_domains())
	}
	}
	end

	def rules_operation do
	%Operation{
	tags: ["Instance misc"],
	summary: "Retrieve list of instance rules",
	operationId: "InstanceController.rules",
	responses: %{
	200 => Operation.response("Array of rules", "application/json", array_of_rules())
	}
	}
	end

	def domain_blocks_operation do
	%Operation{
	tags: ["Instance misc"],
	summary: "Retrieve instance domain blocks",
	operationId: "InstanceController.domain_blocks",
	responses: %{
	200 =>
	Operation.response(
	"Array of domain blocks",
	"application/json",
	array_of_domain_blocks()
	)
	}
	}
	end

	def translation_languages_operation do
	%Operation{
	tags: ["Instance misc"],
	summary: "Retrieve supported languages matrix",
	operationId: "InstanceController.translation_languages",
	responses: %{
	200 =>
	Operation.response(
	"Translation languages matrix",
	"application/json",
	%Schema{
	type: :object,
	additionalProperties: %Schema{
	type: :array,
	items: %Schema{type: :string},
	description: "Supported target languages for a source language"
	}
	}
	)
	}
	}
	end

	defp instance do
	%Schema{
	type: :object,
	properties: %{
	accounts: %Schema{
	type: :object,
	properties: %{
	max_featured_tags: %Schema{
	type: :integer,
	description: "The maximum number of featured tags allowed for each account."
	}
	}
	},
	uri: %Schema{type: :string, description: "The domain name of the instance"},
	title: %Schema{type: :string, description: "The title of the website"},
	description: %Schema{
	type: :string,
	description: "Admin-defined description of the Pleroma site"
	},
	version: %Schema{
	type: :string,
	description: "The version of Pleroma installed on the instance"
	},
	email: %Schema{
	type: :string,
	description: "An email that may be contacted for any inquiries",
	format: :email
	},
	urls: %Schema{
	type: :object,
	description: "URLs of interest for clients apps",
	properties: %{
	streaming_api: %Schema{
	type: :string,
	description: "Websockets address for push streaming"
	}
	}
	},
	stats: %Schema{
	type: :object,
	description: "Statistics about how much information the instance contains",
	properties: %{
	user_count: %Schema{
	type: :integer,
	description: "Users registered on this instance"
	},
	status_count: %Schema{
	type: :integer,
	description: "Statuses authored by users on instance"
	},
	domain_count: %Schema{
	type: :integer,
	description: "Domains federated with this instance"
	}
	}
	},
	thumbnail: %Schema{
	type: :string,
	description: "Banner image for the website",
	nullable: true
	},
	languages: %Schema{
	type: :array,
	items: %Schema{type: :string},
	description: "Primary languages of the website and its staff"
	},
	registrations: %Schema{type: :boolean, description: "Whether registrations are enabled"},
	# Extra (not present in Mastodon):
	max_toot_chars: %Schema{
	type: :integer,
	description: ": Posts character limit (CW/Subject included in the counter)"
	},
	poll_limits: %Schema{
	type: :object,
	description: "A map with poll limits for local polls",
	properties: %{
	max_options: %Schema{
	type: :integer,
	description: "Maximum number of options."
	},
	max_option_chars: %Schema{
	type: :integer,
	description: "Maximum number of characters per option."
	},
	min_expiration: %Schema{
	type: :integer,
	description: "Minimum expiration time (in seconds)."
	},
	max_expiration: %Schema{
	type: :integer,
	description: "Maximum expiration time (in seconds)."
	}
	}
	},
	upload_limit: %Schema{
	type: :integer,
	description: "File size limit of uploads (except for avatar, background, banner)"
	},
	avatar_upload_limit: %Schema{type: :integer, description: "The title of the website"},
	background_upload_limit: %Schema{type: :integer, description: "The title of the website"},
	banner_upload_limit: %Schema{type: :integer, description: "The title of the website"},
	background_image: %Schema{
	type: :string,
	format: :uri,
	description: "The background image for the website"
	}
	},
	example: %{
	"avatar_upload_limit" => 2_000_000,
	"background_upload_limit" => 4_000_000,
	"background_image" => "/static/image.png",
	"banner_upload_limit" => 4_000_000,
	"description" => "Pleroma: An efficient and flexible fediverse server",
	"email" => "lain@lain.com",
	"languages" => ["en"],
	"max_toot_chars" => 5000,
	"poll_limits" => %{
	"max_expiration" => 31_536_000,
	"max_option_chars" => 200,
	"max_options" => 20,
	"min_expiration" => 0
	},
	"registrations" => false,
	"stats" => %{
	"domain_count" => 2996,
	"status_count" => 15_802,
	"user_count" => 5
	},
	"thumbnail" => "https://lain.com/instance/thumbnail.jpeg",
	"title" => "lain.com",
	"upload_limit" => 16_000_000,
	"uri" => "https://lain.com",
	"urls" => %{
	"streaming_api" => "wss://lain.com"
	},
	"version" => "2.7.2 (compatible; Pleroma 2.0.50-536-g25eec6d7-develop)",
	"rules" => array_of_rules()
	}
	}
	end

	defp instance2 do
	%Schema{
	type: :object,
	properties: %{
	domain: %Schema{type: :string, description: "The domain name of the instance"},
	title: %Schema{type: :string, description: "The title of the website"},
	version: %Schema{
	type: :string,
	description: "The version of Pleroma installed on the instance"
	},
	source_url: %Schema{
	type: :string,
	description: "The version of Pleroma installed on the instance"
	},
	description: %Schema{
	type: :string,
	description: "Admin-defined description of the Pleroma site"
	},
	usage: %Schema{
	type: :object,
	description: "Instance usage statistics",
	properties: %{
	users: %Schema{
	type: :object,
	description: "User count statistics",
	properties: %{
	active_month: %Schema{
	type: :integer,
	description: "Monthly active users"
	}
	}
	}
	}
	},
	email: %Schema{
	type: :string,
	description: "An email that may be contacted for any inquiries",
	format: :email
	},
	urls: %Schema{
	type: :object,
	description: "URLs of interest for clients apps",
	properties: %{}
	},
	stats: %Schema{
	type: :object,
	description: "Statistics about how much information the instance contains",
	properties: %{
	user_count: %Schema{
	type: :integer,
	description: "Users registered on this instance"
	},
	status_count: %Schema{
	type: :integer,
	description: "Statuses authored by users on instance"
	},
	domain_count: %Schema{
	type: :integer,
	description: "Domains federated with this instance"
	}
	}
	},
	thumbnail: %Schema{
	type: :object,
	properties: %{
	url: %Schema{
	type: :string,
	description: "Banner image for the website",
	nullable: true
	}
	}
	},
	languages: %Schema{
	type: :array,
	items: %Schema{type: :string},
	description: "Primary languages of the website and its staff"
	},
	registrations: %Schema{
	type: :object,
	description: "Registrations-related configuration",
	properties: %{
	enabled: %Schema{
	type: :boolean,
	description: "Whether registrations are enabled"
	},
	approval_required: %Schema{
	type: :boolean,
	description: "Whether users need to be manually approved by admin"
	}
	}
	},
	configuration: %Schema{
	type: :object,
	description: "Instance configuration",
	properties: %{
	accounts: %Schema{
	type: :object,
	properties: %{
	max_featured_tags: %Schema{
	type: :integer,
	description: "The maximum number of featured tags allowed for each account."
	},
	max_pinned_statuses: %Schema{
	type: :integer,
	description: "The maximum number of pinned statuses for each account."
	+ },
	+ max_profile_fields: %Schema{
	+ type: :integer,
	+ description: "The maximum number of custom profile fields allowed to be set."
	+ },
	+ profile_field_name_limit: %Schema{
	+ type: :integer,
	+ description: "The maximum size of a profile field name, in characters."
	+ },
	+ profile_field_value_limit: %Schema{
	+ type: :integer,
	+ description: "The maximum size of a profile field value, in characters."
	}
	}
	},
	urls: %Schema{
	type: :object,
	properties: %{
	streaming: %Schema{
	type: :string,
	description: "Websockets address for push streaming"
	}
	}
	},
	statuses: %Schema{
	type: :object,
	description: "A map with poll limits for local statuses",
	properties: %{
	characters_reserved_per_url: %Schema{
	type: :integer,
	description:
	"Each URL in a status will be assumed to be exactly this many characters."
	},
	max_characters: %Schema{
	type: :integer,
	description: "Posts character limit (CW/Subject included in the counter)"
	},
	max_media_attachments: %Schema{
	type: :integer,
	description: "Media attachment limit"
	}
	}
	},
	media_attachments: %Schema{
	type: :object,
	description: "A map with poll limits for media attachments",
	properties: %{
	image_size_limit: %Schema{
	type: :integer,
	description: "File size limit of uploaded images"
	},
	video_size_limit: %Schema{
	type: :integer,
	description: "File size limit of uploaded videos"
	}
	}
	},
	polls: %Schema{
	type: :object,
	description: "A map with poll limits for local polls",
	properties: %{
	max_options: %Schema{
	type: :integer,
	description: "Maximum number of options."
	},
	max_characters_per_option: %Schema{
	type: :integer,
	description: "Maximum number of characters per option."
	},
	min_expiration: %Schema{
	type: :integer,
	description: "Minimum expiration time (in seconds)."
	},
	max_expiration: %Schema{
	type: :integer,
	description: "Maximum expiration time (in seconds)."
	}
	}
	}
	}
	}
	}
	}
	end

	defp array_of_domains do
	%Schema{
	type: :array,
	items: %Schema{type: :string},
	example: ["pleroma.site", "lain.com", "bikeshed.party"]
	}
	end

	defp array_of_rules do
	%Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	text: %Schema{type: :string},
	hint: %Schema{type: :string}
	}
	}
	}
	end

	defp array_of_domain_blocks do
	%Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	domain: %Schema{type: :string},
	digest: %Schema{type: :string},
	severity: %Schema{type: :string},
	comment: %Schema{type: :string}
	}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/instance_view.ex b/lib/pleroma/web/mastodon_api/views/instance_view.ex
	index 0dc7a5fea..d64ce4fb5 100644
	--- a/lib/pleroma/web/mastodon_api/views/instance_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/instance_view.ex
	@@ -1,429 +1,438 @@
	# 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.InstanceView do
	use Pleroma.Web, :view

	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

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

	@mastodon_api_level "2.7.2"

	@block_severities %{
	federated_timeline_removal: "silence",
	reject: "suspend"
	}

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

	common_information(instance)
	\|> Map.merge(%{
	uri: Pleroma.Web.WebFinger.host(),
	description: Keyword.get(instance, :description),
	short_description: Keyword.get(instance, :short_description),
	email: Keyword.get(instance, :email),
	urls: %{
	streaming_api: Pleroma.Web.Endpoint.websocket_url()
	},
	stats: Pleroma.Stats.get_stats(),
	thumbnail:
	URI.merge(Pleroma.Web.Endpoint.url(), Keyword.get(instance, :instance_thumbnail))
	\|> to_string,
	registrations: Keyword.get(instance, :registrations_open),
	approval_required: Keyword.get(instance, :account_approval_required),
	contact_account: contact_account(Keyword.get(instance, :contact_username)),
	configuration: configuration(),
	# Extra (not present in Mastodon):
	max_toot_chars: Keyword.get(instance, :limit),
	max_media_attachments: Keyword.get(instance, :max_media_attachments),
	poll_limits: Keyword.get(instance, :poll_limits),
	upload_limit: Keyword.get(instance, :upload_limit),
	avatar_upload_limit: Keyword.get(instance, :avatar_upload_limit),
	background_upload_limit: Keyword.get(instance, :background_upload_limit),
	banner_upload_limit: Keyword.get(instance, :banner_upload_limit),
	background_image: Pleroma.Web.Endpoint.url() <> Keyword.get(instance, :background_image),
	shout_limit: Config.get([:shout, :limit]),
	description_limit: Keyword.get(instance, :description_limit),
	chat_limit: Keyword.get(instance, :chat_limit),
	pleroma: pleroma_configuration(instance)
	})
	end

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

	common_information(instance)
	\|> Map.merge(%{
	domain: Pleroma.Web.WebFinger.host(),
	source_url: Pleroma.Application.repository(),
	description: Keyword.get(instance, :short_description),
	usage: %{users: %{active_month: Pleroma.User.active_user_count()}},
	thumbnail: %{
	url:
	URI.merge(Pleroma.Web.Endpoint.url(), Keyword.get(instance, :instance_thumbnail))
	\|> to_string
	},
	configuration: configuration2(),
	registrations: %{
	enabled: Keyword.get(instance, :registrations_open),
	approval_required: Keyword.get(instance, :account_approval_required),
	message: nil,
	url: nil
	},
	contact: %{
	email: Keyword.get(instance, :email),
	account: contact_account(Keyword.get(instance, :contact_username))
	},
	# Extra (not present in Mastodon):
	pleroma: pleroma_configuration2(instance)
	})
	end

	def render("rules.json", _) do
	Pleroma.Rule.query()
	\|> Pleroma.Repo.all()
	\|> render_many(__MODULE__, "rule.json", as: :rule)
	end

	def render("rule.json", %{rule: rule}) do
	%{
	id: to_string(rule.id),
	text: rule.text,
	hint: rule.hint \|\| ""
	}
	end

	def render("domain_blocks.json", _) do
	if Config.get([:mrf, :transparency]) do
	exclusions = Config.get([:mrf, :transparency_exclusions]) \|> MRF.instance_list_from_tuples()

	domain_blocks =
	Config.get(:mrf_simple)
	\|> Enum.map(fn {rule, instances} ->
	instances
	\|> Enum.map(fn
	{host, reason} when not_empty_string(host) and not_empty_string(reason) ->
	{host, reason}

	{host, _reason} when not_empty_string(host) ->
	{host, ""}

	host when not_empty_string(host) ->
	{host, ""}

	_ ->
	nil
	end)
	\|> Enum.reject(&is_nil/1)
	\|> Enum.reject(fn {host, _} ->
	host in exclusions or not Map.has_key?(@block_severities, rule)
	end)
	\|> Enum.map(fn {host, reason} ->
	domain_block = %{
	domain: host,
	digest: :crypto.hash(:sha256, host) \|> Base.encode16(case: :lower),
	severity: Map.get(@block_severities, rule)
	}

	if not_empty_string(reason) do
	Map.put(domain_block, :comment, reason)
	else
	domain_block
	end
	end)
	end)
	\|> List.flatten()

	domain_blocks
	else
	[]
	end
	end

	def render("translation_languages.json", _) do
	with true <- Pleroma.Language.Translation.configured?(),
	{:ok, languages} <- Pleroma.Language.Translation.languages_matrix() do
	languages
	else
	_ -> %{}
	end
	end

	defp common_information(instance) do
	%{
	languages: Keyword.get(instance, :languages, ["en"]),
	rules: render(__MODULE__, "rules.json"),
	title: Keyword.get(instance, :name),
	version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})"
	}
	end

	def features do
	[
	"pleroma_api",
	"mastodon_api",
	"mastodon_api_streaming",
	"polls",
	"v2_suggestions",
	"pleroma_explicit_addressing",
	"shareable_emoji_packs",
	"multifetch",
	"pleroma:api/v1/notifications:include_types_filter",
	"editing",
	"quote_posting",
	if Config.get([:activitypub, :blockers_visible]) do
	"blockers_visible"
	end,
	if Config.get([:media_proxy, :enabled]) do
	"media_proxy"
	end,
	if Config.get([:gopher, :enabled]) do
	"gopher"
	end,
	# backwards compat
	if Config.get([:shout, :enabled]) do
	"chat"
	end,
	if Config.get([:shout, :enabled]) do
	"shout"
	end,
	if Config.get([:instance, :allow_relay]) do
	"relay"
	end,
	if Config.get([:instance, :safe_dm_mentions]) do
	"safe_dm_mentions"
	end,
	"pleroma_emoji_reactions",
	"pleroma_custom_emoji_reactions",
	"pleroma_chat_messages",
	"pleroma:pin_chats",
	if Config.get([:instance, :show_reactions]) do
	"exposable_reactions"
	end,
	if Config.get([:instance, :profile_directory]) do
	"profile_directory"
	end,
	"pleroma:get:main/ostatus",
	"pleroma:group_actors",
	"pleroma:bookmark_folders",
	if Pleroma.Language.LanguageDetector.configured?() do
	"pleroma:language_detection"
	end,
	"pleroma:block_expiration"
	]
	\|> Enum.filter(& &1)
	end

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

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

	data
	\|> Map.put(
	:quarantined_instances,
	Enum.map(quarantined, fn {instance, _reason} -> instance end)
	)
	# This is for backwards compatibility. We originally didn't sent
	# extra info like a reason why an instance was rejected/quarantined/etc.
	# Because we didn't want to break backwards compatibility it was decided
	# to add an extra "info" key.
	\|> Map.put(:quarantined_instances_info, %{
	"quarantined_instances" =>
	quarantined
	\|> Enum.map(fn {instance, reason} -> {instance, %{"reason" => reason}} end)
	\|> Map.new()
	})
	\|> Map.put(
	:rejected_instances,
	rejected
	\|> Enum.map(fn {instance, reason} -> {instance, %{"reason" => reason}} end)
	\|> Map.new()
	)
	else
	%{}
	end
	\|> Map.put(:enabled, Config.get([:instance, :federating]))
	end

	defp fields_limits do
	%{
	max_fields: Config.get([:instance, :max_account_fields]),
	max_remote_fields: Config.get([:instance, :max_remote_account_fields]),
	name_length: Config.get([:instance, :account_field_name_length]),
	value_length: Config.get([:instance, :account_field_value_length])
	}
	end

	defp contact_account(nil), do: nil

	defp contact_account("@" <> username) do
	contact_account(username)
	end

	defp contact_account(username) do
	user = Pleroma.User.get_cached_by_nickname(username)

	if user do
	Pleroma.Web.MastodonAPI.AccountView.render("show.json", %{user: user, for: nil})
	else
	nil
	end
	end

	defp configuration do
	%{
	accounts: %{
	max_featured_tags: 0
	},
	statuses: %{
	max_characters: Config.get([:instance, :limit]),
	max_media_attachments: Config.get([:instance, :max_media_attachments])
	},
	media_attachments: %{
	image_size_limit: Config.get([:instance, :upload_limit]),
	video_size_limit: Config.get([:instance, :upload_limit]),
	supported_mime_types: ["application/octet-stream"]
	},
	polls: %{
	max_options: Config.get([:instance, :poll_limits, :max_options]),
	max_characters_per_option: Config.get([:instance, :poll_limits, :max_option_chars]),
	min_expiration: Config.get([:instance, :poll_limits, :min_expiration]),
	max_expiration: Config.get([:instance, :poll_limits, :max_expiration])
	}
	}
	end

	defp configuration2 do
	configuration()
	\|> put_in([:accounts, :max_pinned_statuses], Config.get([:instance, :max_pinned_statuses], 0))
	+ \|> put_in([:accounts, :max_profile_fields], Config.get([:instance, :max_account_fields]))
	+ \|> put_in(
	+ [:accounts, :profile_field_name_limit],
	+ Config.get([:instance, :account_field_name_length])
	+ )
	+ \|> put_in(
	+ [:accounts, :profile_field_value_limit],
	+ Config.get([:instance, :account_field_value_length])
	+ )
	\|> put_in([:statuses, :characters_reserved_per_url], 0)
	\|> Map.merge(%{
	urls: %{
	streaming: Pleroma.Web.Endpoint.websocket_url(),
	status: Config.get([:instance, :status_page])
	},
	vapid: %{
	public_key: Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
	},
	translation: %{enabled: Pleroma.Language.Translation.configured?()},
	timelines_access: %{
	live_feeds: timelines_access(),
	hashtag_feeds: timelines_access(),
	# not implemented in Pleroma
	trending_link_feeds: %{
	local: "disabled",
	remote: "disabled"
	}
	}
	})
	end

	defp timelines_access do
	%{
	local: timeline_access(:local),
	remote: timeline_access(:federated)
	}
	end

	defp timeline_access(kind) do
	if Config.restrict_unauthenticated_access?(:timelines, kind) do
	"authenticated"
	else
	"public"
	end
	end

	defp pleroma_configuration(instance) do
	base_urls = %{}

	base_urls =
	if Config.get([:media_proxy, :enabled]) do
	Map.put(base_urls, :media_proxy, Config.get([:media_proxy, :base_url]))
	else
	base_urls
	end

	base_urls =
	case Config.get([Pleroma.Upload, :base_url]) do
	nil -> base_urls
	url -> Map.put(base_urls, :upload, url)
	end

	%{
	metadata: %{
	account_activation_required: Keyword.get(instance, :account_activation_required),
	features: features(),
	federation: federation(),
	fields_limits: fields_limits(),
	post_formats: Config.get([:instance, :allowed_post_formats]),
	birthday_required: Config.get([:instance, :birthday_required]),
	birthday_min_age: Config.get([:instance, :birthday_min_age]),
	translation: supported_languages(),
	base_urls: base_urls,
	markup: markup()
	},
	stats: %{mau: Pleroma.User.active_user_count()},
	vapid_public_key: Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
	}
	end

	defp pleroma_configuration2(instance) do
	configuration = pleroma_configuration(instance)

	configuration
	\|> Map.merge(%{
	metadata:
	configuration.metadata
	\|> Map.merge(%{
	avatar_upload_limit: Keyword.get(instance, :avatar_upload_limit),
	background_upload_limit: Keyword.get(instance, :background_upload_limit),
	banner_upload_limit: Keyword.get(instance, :banner_upload_limit),
	background_image:
	Pleroma.Web.Endpoint.url() <> Keyword.get(instance, :background_image),
	chat_limit: Keyword.get(instance, :chat_limit),
	description_limit: Keyword.get(instance, :description_limit),
	shout_limit: Config.get([:shout, :limit])
	})
	})
	end

	defp supported_languages do
	enabled = Pleroma.Language.Translation.configured?()

	source_languages =
	with true <- enabled,
	{:ok, languages} <- Pleroma.Language.Translation.supported_languages(:source) do
	languages
	else
	_ -> nil
	end

	target_languages =
	with true <- enabled,
	{:ok, languages} <- Pleroma.Language.Translation.supported_languages(:target) do
	languages
	else
	_ -> nil
	end

	%{
	source_languages: source_languages,
	target_languages: target_languages
	}
	end

	defp markup do
	%{
	allow_inline_images: Config.get([:markup, :allow_inline_images]),
	allow_headings: Config.get([:markup, :allow_headings]),
	allow_tables: Config.get([:markup, :allow_tables])
	}
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 29, 8:34 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1736902
Default Alt Text: (29 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions