No OneTemporary
Actions

Size

85 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/api_spec/helpers.ex b/lib/pleroma/web/api_spec/helpers.ex
	index a258e8421..2a7f1a706 100644
	--- a/lib/pleroma/web/api_spec/helpers.ex
	+++ b/lib/pleroma/web/api_spec/helpers.ex
	@@ -1,77 +1,81 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Helpers do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike

	def request_body(description, schema_ref, opts \\ []) do
	media_types = ["application/json", "multipart/form-data", "application/x-www-form-urlencoded"]

	content =
	media_types
	\|> Enum.map(fn type ->
	{type,
	%OpenApiSpex.MediaType{
	schema: schema_ref,
	example: opts[:example],
	examples: opts[:examples]
	}}
	end)
	\|> Enum.into(%{})

	%OpenApiSpex.RequestBody{
	description: description,
	content: content,
	required: opts[:required] \|\| false
	}
	end

	+ def admin_api_params do
	+ [Operation.parameter(:admin_token, :query, :string, "Allows authorization via admin token.")]
	+ end
	+
	def pagination_params do
	[
	Operation.parameter(:max_id, :query, :string, "Return items older than this ID"),
	Operation.parameter(:min_id, :query, :string, "Return the oldest items newer than this ID"),
	Operation.parameter(
	:since_id,
	:query,
	:string,
	"Return the newest items newer than this ID"
	),
	Operation.parameter(
	:offset,
	:query,
	%Schema{type: :integer, default: 0},
	"Return items past this number of items"
	),
	Operation.parameter(
	:limit,
	:query,
	%Schema{type: :integer, default: 20},
	"Maximum number of items to return. Will be ignored if it's more than 40"
	)
	]
	end

	def with_relationships_param do
	Operation.parameter(
	:with_relationships,
	:query,
	BooleanLike,
	"Embed relationships into accounts."
	)
	end

	def empty_object_response do
	Operation.response("Empty object", "application/json", %Schema{type: :object, example: %{}})
	end

	def empty_array_response do
	Operation.response("Empty array", "application/json", %Schema{type: :array, example: []})
	end

	def no_content_response do
	Operation.response("No Content", "application/json", %Schema{type: :string, example: ""})
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/config_operation.ex b/lib/pleroma/web/api_spec/operations/admin/config_operation.ex
	index 7b38a2ef4..3a8380797 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/config_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/config_operation.ex
	@@ -1,142 +1,145 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.ConfigOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

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

	def show_operation do
	%Operation{
	tags: ["Admin", "Config"],
	summary: "Get list of merged default settings with saved in database",
	operationId: "AdminAPI.ConfigController.show",
	parameters: [
	Operation.parameter(
	:only_db,
	:query,
	%Schema{type: :boolean, default: false},
	"Get only saved in database settings"
	)
	+ \| admin_api_params()
	],
	security: [%{"oAuth" => ["read"]}],
	responses: %{
	200 => Operation.response("Config", "application/json", config_response()),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Admin", "Config"],
	summary: "Update config settings",
	operationId: "AdminAPI.ConfigController.update",
	security: [%{"oAuth" => ["write"]}],
	+ parameters: admin_api_params(),
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	configs: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	group: %Schema{type: :string},
	key: %Schema{type: :string},
	value: any(),
	delete: %Schema{type: :boolean},
	subkeys: %Schema{type: :array, items: %Schema{type: :string}}
	}
	}
	}
	}
	}),
	responses: %{
	200 => Operation.response("Config", "application/json", config_response()),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	def descriptions_operation do
	%Operation{
	tags: ["Admin", "Config"],
	summary: "Get JSON with config descriptions.",
	operationId: "AdminAPI.ConfigController.descriptions",
	security: [%{"oAuth" => ["read"]}],
	+ parameters: admin_api_params(),
	responses: %{
	200 =>
	Operation.response("Config Descriptions", "application/json", %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	group: %Schema{type: :string},
	key: %Schema{type: :string},
	type: %Schema{oneOf: [%Schema{type: :string}, %Schema{type: :array}]},
	description: %Schema{type: :string},
	children: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	key: %Schema{type: :string},
	type: %Schema{oneOf: [%Schema{type: :string}, %Schema{type: :array}]},
	description: %Schema{type: :string},
	suggestions: %Schema{type: :array}
	}
	}
	}
	}
	}
	}),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	defp any do
	%Schema{
	oneOf: [
	%Schema{type: :array},
	%Schema{type: :object},
	%Schema{type: :string},
	%Schema{type: :integer},
	%Schema{type: :boolean}
	]
	}
	end

	defp config_response do
	%Schema{
	type: :object,
	properties: %{
	configs: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	group: %Schema{type: :string},
	key: %Schema{type: :string},
	value: any()
	}
	}
	},
	need_reboot: %Schema{
	type: :boolean,
	description:
	"If `need_reboot` is `true`, instance must be restarted, so reboot time settings can take effect"
	}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/invite_operation.ex b/lib/pleroma/web/api_spec/operations/admin/invite_operation.ex
	index d3af9db49..801024d75 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/invite_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/invite_operation.ex
	@@ -1,148 +1,152 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.InviteOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

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

	def index_operation do
	%Operation{
	tags: ["Admin", "Invites"],
	summary: "Get a list of generated invites",
	operationId: "AdminAPI.InviteController.index",
	security: [%{"oAuth" => ["read:invites"]}],
	+ parameters: admin_api_params(),
	responses: %{
	200 =>
	Operation.response("Invites", "application/json", %Schema{
	type: :object,
	properties: %{
	invites: %Schema{type: :array, items: invite()}
	},
	example: %{
	"invites" => [
	%{
	"id" => 123,
	"token" => "kSQtDj_GNy2NZsL9AQDFIsHN5qdbguB6qRg3WHw6K1U=",
	"used" => true,
	"expires_at" => nil,
	"uses" => 0,
	"max_use" => nil,
	"invite_type" => "one_time"
	}
	]
	}
	})
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["Admin", "Invites"],
	summary: "Create an account registration invite token",
	operationId: "AdminAPI.InviteController.create",
	security: [%{"oAuth" => ["write:invites"]}],
	+ parameters: admin_api_params(),
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	max_use: %Schema{type: :integer},
	expires_at: %Schema{type: :string, format: :date, example: "2020-04-20"}
	}
	}),
	responses: %{
	200 => Operation.response("Invite", "application/json", invite())
	}
	}
	end

	def revoke_operation do
	%Operation{
	tags: ["Admin", "Invites"],
	summary: "Revoke invite by token",
	operationId: "AdminAPI.InviteController.revoke",
	security: [%{"oAuth" => ["write:invites"]}],
	+ parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	required: [:token],
	properties: %{
	token: %Schema{type: :string}
	}
	},
	required: true
	),
	responses: %{
	200 => Operation.response("Invite", "application/json", invite()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def email_operation do
	%Operation{
	tags: ["Admin", "Invites"],
	summary: "Sends registration invite via email",
	operationId: "AdminAPI.InviteController.email",
	security: [%{"oAuth" => ["write:invites"]}],
	+ parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	required: [:email],
	properties: %{
	email: %Schema{type: :string, format: :email},
	name: %Schema{type: :string}
	}
	},
	required: true
	),
	responses: %{
	204 => no_content_response(),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	defp invite do
	%Schema{
	title: "Invite",
	type: :object,
	properties: %{
	id: %Schema{type: :integer},
	token: %Schema{type: :string},
	used: %Schema{type: :boolean},
	expires_at: %Schema{type: :string, format: :date, nullable: true},
	uses: %Schema{type: :integer},
	max_use: %Schema{type: :integer, nullable: true},
	invite_type: %Schema{
	type: :string,
	enum: ["one_time", "reusable", "date_limited", "reusable_date_limited"]
	}
	},
	example: %{
	"id" => 123,
	"token" => "kSQtDj_GNy2NZsL9AQDFIsHN5qdbguB6qRg3WHw6K1U=",
	"used" => true,
	"expires_at" => nil,
	"uses" => 0,
	"max_use" => nil,
	"invite_type" => "one_time"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/media_proxy_cache_operation.ex b/lib/pleroma/web/api_spec/operations/admin/media_proxy_cache_operation.ex
	index 0358cfbad..20d033f66 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/media_proxy_cache_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/media_proxy_cache_operation.ex
	@@ -1,109 +1,112 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.MediaProxyCacheOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

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

	def index_operation do
	%Operation{
	tags: ["Admin", "MediaProxyCache"],
	summary: "Fetch a paginated list of all banned MediaProxy URLs in Cachex",
	operationId: "AdminAPI.MediaProxyCacheController.index",
	security: [%{"oAuth" => ["read:media_proxy_caches"]}],
	parameters: [
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number of statuses to return"
	)
	+ \| admin_api_params()
	],
	responses: %{
	200 => success_response()
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Admin", "MediaProxyCache"],
	summary: "Remove a banned MediaProxy URL from Cachex",
	operationId: "AdminAPI.MediaProxyCacheController.delete",
	security: [%{"oAuth" => ["write:media_proxy_caches"]}],
	+ parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	required: [:urls],
	properties: %{
	urls: %Schema{type: :array, items: %Schema{type: :string, format: :uri}}
	}
	},
	required: true
	),
	responses: %{
	200 => success_response(),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def purge_operation do
	%Operation{
	tags: ["Admin", "MediaProxyCache"],
	summary: "Purge and optionally ban a MediaProxy URL",
	operationId: "AdminAPI.MediaProxyCacheController.purge",
	security: [%{"oAuth" => ["write:media_proxy_caches"]}],
	+ parameters: admin_api_params(),
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	required: [:urls],
	properties: %{
	urls: %Schema{type: :array, items: %Schema{type: :string, format: :uri}},
	ban: %Schema{type: :boolean, default: true}
	}
	},
	required: true
	),
	responses: %{
	200 => success_response(),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp success_response do
	Operation.response("Array of banned MediaProxy URLs in Cachex", "application/json", %Schema{
	type: :object,
	properties: %{
	urls: %Schema{
	type: :array,
	items: %Schema{
	type: :string,
	format: :uri,
	description: "MediaProxy URLs"
	}
	}
	}
	})
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/oauth_app_operation.ex b/lib/pleroma/web/api_spec/operations/admin/oauth_app_operation.ex
	index fbc9f80d7..a75f3e622 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/oauth_app_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/oauth_app_operation.ex
	@@ -1,215 +1,217 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.OAuthAppOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

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

	def index_operation do
	%Operation{
	summary: "List OAuth apps",
	tags: ["Admin", "oAuth Apps"],
	operationId: "AdminAPI.OAuthAppController.index",
	security: [%{"oAuth" => ["write"]}],
	parameters: [
	Operation.parameter(:name, :query, %Schema{type: :string}, "App name"),
	Operation.parameter(:client_id, :query, %Schema{type: :string}, "Client ID"),
	Operation.parameter(:page, :query, %Schema{type: :integer, default: 1}, "Page"),
	Operation.parameter(
	:trusted,
	:query,
	%Schema{type: :boolean, default: false},
	"Trusted apps"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number of apps to return"
	)
	+ \| admin_api_params()
	],
	responses: %{
	200 =>
	Operation.response("List of apps", "application/json", %Schema{
	type: :object,
	properties: %{
	apps: %Schema{type: :array, items: oauth_app()},
	count: %Schema{type: :integer},
	page_size: %Schema{type: :integer}
	},
	example: %{
	"apps" => [
	%{
	"id" => 1,
	"name" => "App name",
	"client_id" => "yHoDSiWYp5mPV6AfsaVOWjdOyt5PhWRiafi6MRd1lSk",
	"client_secret" => "nLmis486Vqrv2o65eM9mLQx_m_4gH-Q6PcDpGIMl6FY",
	"redirect_uri" => "https://example.com/oauth-callback",
	"website" => "https://example.com",
	"trusted" => true
	}
	],
	"count" => 1,
	"page_size" => 50
	}
	})
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["Admin", "oAuth Apps"],
	summary: "Create OAuth App",
	operationId: "AdminAPI.OAuthAppController.create",
	requestBody: request_body("Parameters", create_request()),
	+ parameters: admin_api_params(),
	security: [%{"oAuth" => ["write"]}],
	responses: %{
	200 => Operation.response("App", "application/json", oauth_app()),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Admin", "oAuth Apps"],
	summary: "Update OAuth App",
	operationId: "AdminAPI.OAuthAppController.update",
	- parameters: [id_param()],
	+ parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["write"]}],
	requestBody: request_body("Parameters", update_request()),
	responses: %{
	200 => Operation.response("App", "application/json", oauth_app()),
	400 =>
	Operation.response("Bad Request", "application/json", %Schema{
	oneOf: [ApiError, %Schema{type: :string}]
	})
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Admin", "oAuth Apps"],
	summary: "Delete OAuth App",
	operationId: "AdminAPI.OAuthAppController.delete",
	- parameters: [id_param()],
	+ parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["write"]}],
	responses: %{
	204 => no_content_response(),
	400 => no_content_response()
	}
	}
	end

	defp create_request do
	%Schema{
	title: "oAuthAppCreateRequest",
	type: :object,
	required: [:name, :redirect_uris],
	properties: %{
	name: %Schema{type: :string, description: "Application Name"},
	scopes: %Schema{type: :array, items: %Schema{type: :string}, description: "oAuth scopes"},
	redirect_uris: %Schema{
	type: :string,
	description:
	"Where the user should be redirected after authorization. To display the authorization code to the user instead of redirecting to a web page, use `urn:ietf:wg:oauth:2.0:oob` in this parameter."
	},
	website: %Schema{
	type: :string,
	nullable: true,
	description: "A URL to the homepage of the app"
	},
	trusted: %Schema{
	type: :boolean,
	nullable: true,
	default: false,
	description: "Is the app trusted?"
	}
	},
	example: %{
	"name" => "My App",
	"redirect_uris" => "https://myapp.com/auth/callback",
	"website" => "https://myapp.com/",
	"scopes" => ["read", "write"],
	"trusted" => true
	}
	}
	end

	defp update_request do
	%Schema{
	title: "oAuthAppUpdateRequest",
	type: :object,
	properties: %{
	name: %Schema{type: :string, description: "Application Name"},
	scopes: %Schema{type: :array, items: %Schema{type: :string}, description: "oAuth scopes"},
	redirect_uris: %Schema{
	type: :string,
	description:
	"Where the user should be redirected after authorization. To display the authorization code to the user instead of redirecting to a web page, use `urn:ietf:wg:oauth:2.0:oob` in this parameter."
	},
	website: %Schema{
	type: :string,
	nullable: true,
	description: "A URL to the homepage of the app"
	},
	trusted: %Schema{
	type: :boolean,
	nullable: true,
	default: false,
	description: "Is the app trusted?"
	}
	},
	example: %{
	"name" => "My App",
	"redirect_uris" => "https://myapp.com/auth/callback",
	"website" => "https://myapp.com/",
	"scopes" => ["read", "write"],
	"trusted" => true
	}
	}
	end

	defp oauth_app do
	%Schema{
	title: "oAuthApp",
	type: :object,
	properties: %{
	id: %Schema{type: :integer},
	name: %Schema{type: :string},
	client_id: %Schema{type: :string},
	client_secret: %Schema{type: :string},
	redirect_uri: %Schema{type: :string},
	website: %Schema{type: :string, nullable: true},
	trusted: %Schema{type: :boolean}
	},
	example: %{
	"id" => 123,
	"name" => "My App",
	"client_id" => "TWhM-tNSuncnqN7DBJmoyeLnk6K3iJJ71KKXxgL1hPM",
	"client_secret" => "ZEaFUFmF0umgBX1qKJDjaU99Q31lDkOU8NutzTOoliw",
	"redirect_uri" => "https://myapp.com/oauth-callback",
	"website" => "https://myapp.com/",
	"trusted" => false
	}
	}
	end

	def id_param do
	Operation.parameter(:id, :path, :integer, "App ID",
	example: 1337,
	required: true
	)
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex b/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	index 7672cb467..67ee5eee0 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	@@ -1,83 +1,86 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.RelayOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema

	import Pleroma.Web.ApiSpec.Helpers

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

	def index_operation do
	%Operation{
	tags: ["Admin", "Relays"],
	summary: "List Relays",
	operationId: "AdminAPI.RelayController.index",
	security: [%{"oAuth" => ["read"]}],
	+ parameters: admin_api_params(),
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{
	relays: %Schema{
	type: :array,
	items: %Schema{type: :string},
	example: ["lain.com", "mstdn.io"]
	}
	}
	})
	}
	}
	end

	def follow_operation do
	%Operation{
	tags: ["Admin", "Relays"],
	summary: "Follow a Relay",
	operationId: "AdminAPI.RelayController.follow",
	security: [%{"oAuth" => ["write:follows"]}],
	+ parameters: admin_api_params(),
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	relay_url: %Schema{type: :string, format: :uri}
	}
	}),
	responses: %{
	200 =>
	Operation.response("Status", "application/json", %Schema{
	type: :string,
	example: "http://mastodon.example.org/users/admin"
	})
	}
	}
	end

	def unfollow_operation do
	%Operation{
	tags: ["Admin", "Relays"],
	summary: "Unfollow a Relay",
	operationId: "AdminAPI.RelayController.unfollow",
	security: [%{"oAuth" => ["write:follows"]}],
	+ parameters: admin_api_params(),
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	relay_url: %Schema{type: :string, format: :uri}
	}
	}),
	responses: %{
	200 =>
	Operation.response("Status", "application/json", %Schema{
	type: :string,
	example: "http://mastodon.example.org/users/admin"
	})
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/report_operation.ex b/lib/pleroma/web/api_spec/operations/admin/report_operation.ex
	index 15e78bfaf..3bb7ec49e 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/report_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/report_operation.ex
	@@ -1,237 +1,240 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.ReportOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.Schemas.Status

	import Pleroma.Web.ApiSpec.Helpers

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

	def index_operation do
	%Operation{
	tags: ["Admin", "Reports"],
	summary: "Get a list of reports",
	operationId: "AdminAPI.ReportController.index",
	security: [%{"oAuth" => ["read:reports"]}],
	parameters: [
	Operation.parameter(
	:state,
	:query,
	report_state(),
	"Filter by report state"
	),
	Operation.parameter(
	:limit,
	:query,
	%Schema{type: :integer},
	"The number of records to retrieve"
	),
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page number"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number number of log entries per page"
	)
	+ \| admin_api_params()
	],
	responses: %{
	200 =>
	Operation.response("Response", "application/json", %Schema{
	type: :object,
	properties: %{
	total: %Schema{type: :integer},
	reports: %Schema{
	type: :array,
	items: report()
	}
	}
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Admin", "Reports"],
	summary: "Get an individual report",
	operationId: "AdminAPI.ReportController.show",
	- parameters: [id_param()],
	+ parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["read:reports"]}],
	responses: %{
	200 => Operation.response("Report", "application/json", report()),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Admin", "Reports"],
	summary: "Change the state of one or multiple reports",
	operationId: "AdminAPI.ReportController.update",
	security: [%{"oAuth" => ["write:reports"]}],
	+ parameters: admin_api_params(),
	requestBody: request_body("Parameters", update_request(), required: true),
	responses: %{
	204 => no_content_response(),
	400 => Operation.response("Bad Request", "application/json", update_400_response()),
	403 => Operation.response("Forbidden", "application/json", ApiError)
	}
	}
	end

	def notes_create_operation do
	%Operation{
	tags: ["Admin", "Reports"],
	summary: "Create report note",
	operationId: "AdminAPI.ReportController.notes_create",
	- parameters: [id_param()],
	+ parameters: [id_param() \| admin_api_params()],
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	content: %Schema{type: :string, description: "The message"}
	}
	}),
	security: [%{"oAuth" => ["write:reports"]}],
	responses: %{
	204 => no_content_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def notes_delete_operation do
	%Operation{
	tags: ["Admin", "Reports"],
	summary: "Delete report note",
	operationId: "AdminAPI.ReportController.notes_delete",
	parameters: [
	Operation.parameter(:report_id, :path, :string, "Report ID"),
	Operation.parameter(:id, :path, :string, "Note ID")
	+ \| admin_api_params()
	],
	security: [%{"oAuth" => ["write:reports"]}],
	responses: %{
	204 => no_content_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	defp report_state do
	%Schema{type: :string, enum: ["open", "closed", "resolved"]}
	end

	defp id_param do
	Operation.parameter(:id, :path, FlakeID, "Report ID",
	example: "9umDrYheeY451cQnEe",
	required: true
	)
	end

	defp report do
	%Schema{
	type: :object,
	properties: %{
	id: FlakeID,
	state: report_state(),
	account: account_admin(),
	actor: account_admin(),
	content: %Schema{type: :string},
	created_at: %Schema{type: :string, format: :"date-time"},
	statuses: %Schema{type: :array, items: Status},
	notes: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	id: %Schema{type: :integer},
	user_id: FlakeID,
	content: %Schema{type: :string},
	inserted_at: %Schema{type: :string, format: :"date-time"}
	}
	}
	}
	}
	}
	end

	defp account_admin do
	%Schema{
	title: "Account",
	description: "Account view for admins",
	type: :object,
	properties:
	Map.merge(Account.schema().properties, %{
	nickname: %Schema{type: :string},
	deactivated: %Schema{type: :boolean},
	local: %Schema{type: :boolean},
	roles: %Schema{
	type: :object,
	properties: %{
	admin: %Schema{type: :boolean},
	moderator: %Schema{type: :boolean}
	}
	},
	confirmation_pending: %Schema{type: :boolean}
	})
	}
	end

	defp update_request do
	%Schema{
	type: :object,
	required: [:reports],
	properties: %{
	reports: %Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	id: %Schema{allOf: [FlakeID], description: "Required, report ID"},
	state: %Schema{
	type: :string,
	description:
	"Required, the new state. Valid values are `open`, `closed` and `resolved`"
	}
	}
	},
	example: %{
	"reports" => [
	%{"id" => "123", "state" => "closed"},
	%{"id" => "1337", "state" => "resolved"}
	]
	}
	}
	}
	}
	end

	defp update_400_response do
	%Schema{
	type: :array,
	items: %Schema{
	type: :object,
	properties: %{
	id: %Schema{allOf: [FlakeID], description: "Report ID"},
	error: %Schema{type: :string, description: "Error message"}
	}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/status_operation.ex b/lib/pleroma/web/api_spec/operations/admin/status_operation.ex
	index 745399b4b..c105838a4 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/status_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/status_operation.ex
	@@ -1,165 +1,166 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.Admin.StatusOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.Schemas.Status
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	import Pleroma.Web.ApiSpec.Helpers
	import Pleroma.Web.ApiSpec.StatusOperation, only: [id_param: 0]

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

	def index_operation do
	%Operation{
	tags: ["Admin", "Statuses"],
	operationId: "AdminAPI.StatusController.index",
	security: [%{"oAuth" => ["read:statuses"]}],
	parameters: [
	Operation.parameter(
	:godmode,
	:query,
	%Schema{type: :boolean, default: false},
	"Allows to see private statuses"
	),
	Operation.parameter(
	:local_only,
	:query,
	%Schema{type: :boolean, default: false},
	"Excludes remote statuses"
	),
	Operation.parameter(
	:with_reblogs,
	:query,
	%Schema{type: :boolean, default: false},
	"Allows to see reblogs"
	),
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number of statuses to return"
	)
	+ \| admin_api_params()
	],
	responses: %{
	200 =>
	Operation.response("Array of statuses", "application/json", %Schema{
	type: :array,
	items: status()
	})
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Admin", "Statuses"],
	summary: "Show Status",
	operationId: "AdminAPI.StatusController.show",
	- parameters: [id_param()],
	+ parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["read:statuses"]}],
	responses: %{
	200 => Operation.response("Status", "application/json", status()),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Admin", "Statuses"],
	summary: "Change the scope of an individual reported status",
	operationId: "AdminAPI.StatusController.update",
	- parameters: [id_param()],
	+ parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["write:statuses"]}],
	requestBody: request_body("Parameters", update_request(), required: true),
	responses: %{
	200 => Operation.response("Status", "application/json", Status),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Admin", "Statuses"],
	summary: "Delete an individual reported status",
	operationId: "AdminAPI.StatusController.delete",
	- parameters: [id_param()],
	+ parameters: [id_param() \| admin_api_params()],
	security: [%{"oAuth" => ["write:statuses"]}],
	responses: %{
	200 => empty_object_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	defp status do
	%Schema{
	anyOf: [
	Status,
	%Schema{
	type: :object,
	properties: %{
	account: %Schema{allOf: [Account, admin_account()]}
	}
	}
	]
	}
	end

	def admin_account do
	%Schema{
	type: :object,
	properties: %{
	id: FlakeID,
	avatar: %Schema{type: :string},
	nickname: %Schema{type: :string},
	display_name: %Schema{type: :string},
	deactivated: %Schema{type: :boolean},
	local: %Schema{type: :boolean},
	roles: %Schema{
	type: :object,
	properties: %{
	admin: %Schema{type: :boolean},
	moderator: %Schema{type: :boolean}
	}
	},
	tags: %Schema{type: :string},
	confirmation_pending: %Schema{type: :string}
	}
	}
	end

	defp update_request do
	%Schema{
	type: :object,
	properties: %{
	sensitive: %Schema{
	type: :boolean,
	description: "Mark status and attached media as sensitive?"
	},
	visibility: VisibilityScope
	},
	example: %{
	"visibility" => "private",
	"sensitive" => "false"
	}
	}
	end
	end
	diff --git a/test/web/admin_api/controllers/config_controller_test.exs b/test/web/admin_api/controllers/config_controller_test.exs
	index 064ef9bc7..61bc9fd39 100644
	--- a/test/web/admin_api/controllers/config_controller_test.exs
	+++ b/test/web/admin_api/controllers/config_controller_test.exs
	@@ -1,1388 +1,1396 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.ConfigControllerTest do
	use Pleroma.Web.ConnCase, async: true

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.Config
	alias Pleroma.ConfigDB

	setup do
	admin = insert(:user, is_admin: true)
	token = insert(:oauth_admin_token, user: admin)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)

	{:ok, %{admin: admin, token: token, conn: conn}}
	end

	describe "GET /api/pleroma/admin/config" do
	setup do: clear_config(:configurable_from_database, true)

	test "when configuration from database is off", %{conn: conn} do
	Config.put(:configurable_from_database, false)
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response_and_validate_schema(conn, 400) ==
	%{
	"error" => "To use this endpoint you need to enable configuration from database."
	}
	end

	test "with settings only in db", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	conn = get(conn, "/api/pleroma/admin/config?only_db=true")

	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => key1,
	"value" => _
	},
	%{
	"group" => ":pleroma",
	"key" => key2,
	"value" => _
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert key1 == inspect(config1.key)
	assert key2 == inspect(config2.key)
	end

	test "db is added to settings that are in db", %{conn: conn} do
	_config = insert(:config, key: ":instance", value: [name: "Some name"])

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	[instance_config] =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key == ":instance"
	end)

	assert instance_config["db"] == [":name"]
	end

	test "merged default setting with db settings", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	config3 =
	insert(:config,
	value: [k1: :v1, k2: :v2]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert length(configs) > 3

	saved_configs = [config1, config2, config3]
	keys = Enum.map(saved_configs, &inspect(&1.key))

	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in keys
	end)

	assert length(received_configs) == 3

	db_keys =
	config3.value
	\|> Keyword.keys()
	\|> ConfigDB.to_json_types()

	keys = Enum.map(saved_configs -- [config3], &inspect(&1.key))

	values = Enum.map(saved_configs, &ConfigDB.to_json_types(&1.value))

	mapset_keys = MapSet.new(keys ++ db_keys)

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	db = MapSet.new(db)
	assert MapSet.subset?(db, mapset_keys)

	assert value in values
	end)
	end

	test "subkeys with full update right merge", %{conn: conn} do
	insert(:config,
	key: ":emoji",
	value: [groups: [a: 1, b: 2], key: [a: 1]]
	)

	insert(:config,
	key: ":assets",
	value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

	%{"configs" => configs} =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	vals =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in [":emoji", ":assets"]
	end)

	emoji = Enum.find(vals, fn %{"key" => key} -> key == ":emoji" end)
	assets = Enum.find(vals, fn %{"key" => key} -> key == ":assets" end)

	emoji_val = ConfigDB.to_elixir_types(emoji["value"])
	assets_val = ConfigDB.to_elixir_types(assets["value"])

	assert emoji_val[:groups] == [a: 1, b: 2]
	assert assets_val[:mascots] == [a: 1, b: 2]
	end
	+
	+ test "with valid `admin_token` query parameter, skips OAuth scopes check" do
	+ clear_config([:admin_token], "password123")
	+
	+ build_conn()
	+ \|> get("/api/pleroma/admin/config?admin_token=password123")
	+ \|> json_response_and_validate_schema(200)
	+ end
	end

	test "POST /api/pleroma/admin/config error", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{"configs" => []})

	assert json_response_and_validate_schema(conn, 400) ==
	%{"error" => "To use this endpoint you need to enable configuration from database."}
	end

	describe "POST /api/pleroma/admin/config" do
	setup do
	http = Application.get_env(:pleroma, :http)

	on_exit(fn ->
	Application.delete_env(:pleroma, :key1)
	Application.delete_env(:pleroma, :key2)
	Application.delete_env(:pleroma, :key3)
	Application.delete_env(:pleroma, :key4)
	Application.delete_env(:pleroma, :keyaa1)
	Application.delete_env(:pleroma, :keyaa2)
	Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
	Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
	Application.put_env(:pleroma, :http, http)
	Application.put_env(:tesla, :adapter, Tesla.Mock)
	Restarter.Pleroma.refresh()
	end)
	end

	setup do: clear_config(:configurable_from_database, true)

	@tag capture_log: true
	test "create new config setting in db", %{conn: conn} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	on_exit(fn -> Application.put_env(:ueberauth, Ueberauth, ueberauth) end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
	},
	%{
	group: ":pleroma",
	key: ":key2",
	value: %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	}
	},
	%{
	group: ":pleroma",
	key: ":key3",
	value: [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	group: ":pleroma",
	key: ":key4",
	value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
	},
	%{
	group: ":idna",
	key: ":key5",
	value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => "value1",
	"db" => [":key1"]
	},
	%{
	"group" => ":ueberauth",
	"key" => "Ueberauth",
	"value" => [%{"tuple" => [":consumer_secret", "aaaa"]}],
	"db" => [":consumer_secret"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key2",
	"value" => %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	},
	"db" => [":key2"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key3",
	"value" => [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	],
	"db" => [":key3"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":key4",
	"value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"},
	"db" => [":key4"]
	},
	%{
	"group" => ":idna",
	"key" => ":key5",
	"value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]},
	"db" => [":key5"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == "value1"

	assert Application.get_env(:pleroma, :key2) == %{
	nested_1: "nested_value1",
	nested_2: [
	%{nested_22: "nested_value222"},
	%{nested_33: %{nested_44: "nested_444"}}
	]
	}

	assert Application.get_env(:pleroma, :key3) == [
	%{"nested_3" => :nested_3, "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]

	assert Application.get_env(:pleroma, :key4) == %{
	"endpoint" => "https://example.com",
	nested_5: :upload
	}

	assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
	end

	test "save configs setting without explicit key", %{conn: conn} do
	level = Application.get_env(:quack, :level)
	meta = Application.get_env(:quack, :meta)
	webhook_url = Application.get_env(:quack, :webhook_url)

	on_exit(fn ->
	Application.put_env(:quack, :level, level)
	Application.put_env(:quack, :meta, meta)
	Application.put_env(:quack, :webhook_url, webhook_url)
	end)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":quack",
	key: ":level",
	value: ":info"
	},
	%{
	group: ":quack",
	key: ":meta",
	value: [":none"]
	},
	%{
	group: ":quack",
	key: ":webhook_url",
	value: "https://hooks.slack.com/services/KEY"
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":quack",
	"key" => ":level",
	"value" => ":info",
	"db" => [":level"]
	},
	%{
	"group" => ":quack",
	"key" => ":meta",
	"value" => [":none"],
	"db" => [":meta"]
	},
	%{
	"group" => ":quack",
	"key" => ":webhook_url",
	"value" => "https://hooks.slack.com/services/KEY",
	"db" => [":webhook_url"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:quack, :level) == :info
	assert Application.get_env(:quack, :meta) == [:none]
	assert Application.get_env(:quack, :webhook_url) == "https://hooks.slack.com/services/KEY"
	end

	test "saving config with partial update", %{conn: conn} do
	insert(:config, key: ":key1", value: :erlang.term_to_binary(key1: 1, key2: 2))

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key2", 2]},
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key1", ":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving config which need pleroma reboot", %{conn: conn} do
	chat = Config.get(:chat)
	on_exit(fn -> Config.put(:chat, chat) end)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":chat", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":chat",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"]

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "update setting which need reboot, don't change reboot flag until reboot", %{conn: conn} do
	chat = Config.get(:chat)
	on_exit(fn -> Config.put(:chat, chat) end)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post(
	"/api/pleroma/admin/config",
	%{
	configs: [
	%{group: ":pleroma", key: ":chat", value: [%{"tuple" => [":enabled", true]}]}
	]
	}
	)
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"db" => [":enabled"],
	"group" => ":pleroma",
	"key" => ":chat",
	"value" => [%{"tuple" => [":enabled", true]}]
	}
	],
	"need_reboot" => true
	}

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: [%{"tuple" => [":key3", 3]}]}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key3", 3]}
	],
	"db" => [":key3"]
	}
	],
	"need_reboot" => true
	}

	capture_log(fn ->
	assert conn \|> get("/api/pleroma/admin/restart") \|> json_response(200) ==
	%{}
	end) =~ "pleroma restarted"

	configs =
	conn
	\|> get("/api/pleroma/admin/config")
	\|> json_response_and_validate_schema(200)

	assert configs["need_reboot"] == false
	end

	test "saving config with nested merge", %{conn: conn} do
	insert(:config, key: :key1, value: [key1: 1, key2: [k1: 1, k2: 2]])

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":key1",
	value: [
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key1", 1]},
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k1", 1]},
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	],
	"db" => [":key1", ":key3", ":key2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "saving special atoms", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{
	"tuple" => [
	":ssl_options",
	[%{"tuple" => [":versions", [":tlsv1", ":tlsv1.1", ":tlsv1.2"]]}]
	]
	}
	],
	"db" => [":ssl_options"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :key1) == [
	ssl_options: [versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]]
	]
	end

	test "saving full setting if value is in full_key_update list", %{conn: conn} do
	backends = Application.get_env(:logger, :backends)
	on_exit(fn -> Application.put_env(:logger, :backends, backends) end)

	insert(:config,
	group: :logger,
	key: :backends,
	value: []
	)

	Pleroma.Config.TransferTask.load_and_update_env([], false)

	assert Application.get_env(:logger, :backends) == []

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":logger",
	key: ":backends",
	value: [":console"]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":logger",
	"key" => ":backends",
	"value" => [
	":console"
	],
	"db" => [":backends"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:logger, :backends) == [
	:console
	]
	end

	test "saving full setting if value is not keyword", %{conn: conn} do
	insert(:config,
	group: :tesla,
	key: :adapter,
	value: Tesla.Adapter.Hackey
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":tesla", key: ":adapter", value: "Tesla.Adapter.Httpc"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":tesla",
	"key" => ":adapter",
	"value" => "Tesla.Adapter.Httpc",
	"db" => [":adapter"]
	}
	],
	"need_reboot" => false
	}
	end

	test "update config setting & delete with fallback to default value", %{
	conn: conn,
	admin: admin,
	token: token
	} do
	ueberauth = Application.get_env(:ueberauth, Ueberauth)
	insert(:config, key: :keyaa1)
	insert(:config, key: :keyaa2)

	config3 =
	insert(:config,
	group: :ueberauth,
	key: Ueberauth
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa1", value: "another_value"},
	%{group: ":pleroma", key: ":keyaa2", value: "another_value"}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => "another_value",
	"db" => [":keyaa1"]
	},
	%{
	"group" => ":pleroma",
	"key" => ":keyaa2",
	"value" => "another_value",
	"db" => [":keyaa2"]
	}
	],
	"need_reboot" => false
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	assert Application.get_env(:pleroma, :keyaa2) == "another_value"
	assert Application.get_env(:ueberauth, Ueberauth) == config3.value

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":keyaa2", delete: true},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [],
	"need_reboot" => false
	}

	assert Application.get_env(:ueberauth, Ueberauth) == ueberauth
	refute Keyword.has_key?(Application.get_all_env(:pleroma), :keyaa2)
	end

	test "common config example", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\/\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\/\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\/\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\/\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	]
	}
	]
	})

	assert Config.get([Pleroma.Captcha.NotReal, :name]) == "Pleroma"

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	],
	"db" => [
	":enabled",
	":method",
	":seconds_valid",
	":path",
	":key1",
	":partial_chain",
	":regex1",
	":regex2",
	":regex3",
	":regex4",
	":name"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "tuples with more than two values", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	],
	"db" => [":http"]
	}
	],
	"need_reboot" => false
	}
	end

	test "settings with nesting map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000,
	"nested" => %{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000
	}
	}
	]
	}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0,
	"nested" => %{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0
	}
	}
	]
	}
	],
	"db" => [":key2", ":key3"]
	}
	],
	"need_reboot" => false
	}
	end

	test "value as map", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"},
	"db" => [":key1"]
	}
	],
	"need_reboot" => false
	}
	end

	test "queues key as atom", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	]
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":oban",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	],
	"db" => [
	":federator_incoming",
	":federator_outgoing",
	":web_push",
	":mailer",
	":transmogrifier",
	":scheduled_activities",
	":background"
	]
	}
	],
	"need_reboot" => false
	}
	end

	test "delete part of settings by atom subkeys", %{conn: conn} do
	insert(:config,
	key: :keyaa1,
	value: [subkey1: "val1", subkey2: "val2", subkey3: "val3"]
	)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":keyaa1",
	subkeys: [":subkey1", ":subkey3"],
	delete: true
	}
	]
	})

	assert json_response_and_validate_schema(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":keyaa1",
	"value" => [%{"tuple" => [":subkey2", "val2"]}],
	"db" => [":subkey2"]
	}
	],
	"need_reboot" => false
	}
	end

	test "proxy tuple localhost", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple domain", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]} in value
	assert ":proxy_url" in db
	end

	test "proxy tuple ip", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: ":http",
	value: [
	%{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]}
	]
	}
	]
	})

	assert %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => ":http",
	"value" => value,
	"db" => db
	}
	]
	} = json_response_and_validate_schema(conn, 200)

	assert %{"tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]} in value
	assert ":proxy_url" in db
	end

	@tag capture_log: true
	test "doesn't set keys not in the whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :key1},
	{:pleroma, :key2},
	{:pleroma, Pleroma.Captcha.NotReal},
	{:not_real}
	])

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: ":pleroma", key: ":key1", value: "value1"},
	%{group: ":pleroma", key: ":key2", value: "value2"},
	%{group: ":pleroma", key: ":key3", value: "value3"},
	%{group: ":pleroma", key: "Pleroma.Web.Endpoint.NotReal", value: "value4"},
	%{group: ":pleroma", key: "Pleroma.Captcha.NotReal", value: "value5"},
	%{group: ":not_real", key: ":anything", value: "value6"}
	]
	})

	assert Application.get_env(:pleroma, :key1) == "value1"
	assert Application.get_env(:pleroma, :key2) == "value2"
	assert Application.get_env(:pleroma, :key3) == nil
	assert Application.get_env(:pleroma, Pleroma.Web.Endpoint.NotReal) == nil
	assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == "value5"
	assert Application.get_env(:not_real, :anything) == "value6"
	end

	test "args for Pleroma.Upload.Filter.Mogrify with custom tuples", %{conn: conn} do
	clear_config(Pleroma.Upload.Filter.Mogrify)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	]
	}
	]
	})
	\|> json_response_and_validate_schema(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{"tuple" => [":args", ["auto-orient", "strip"]]}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	assert Config.get(Pleroma.Upload.Filter.Mogrify) == [args: ["auto-orient", "strip"]]

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":pleroma",
	key: "Pleroma.Upload.Filter.Mogrify",
	value: [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	]
	}
	]
	})
	\|> json_response(200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Upload.Filter.Mogrify",
	"value" => [
	%{
	"tuple" => [
	":args",
	[
	"auto-orient",
	"strip",
	"{\"implode\", \"1\"}",
	"{\"resize\", \"3840x1080>\"}"
	]
	]
	}
	],
	"db" => [":args"]
	}
	],
	"need_reboot" => false
	}

	assert Config.get(Pleroma.Upload.Filter.Mogrify) == [
	args: ["auto-orient", "strip", {"implode", "1"}, {"resize", "3840x1080>"}]
	]
	end
	end

	describe "GET /api/pleroma/admin/config/descriptions" do
	test "structure", %{conn: conn} do
	admin = insert(:user, is_admin: true)

	conn =
	assign(conn, :user, admin)
	\|> get("/api/pleroma/admin/config/descriptions")

	assert [child \| _others] = json_response_and_validate_schema(conn, 200)

	assert child["children"]
	assert child["key"]
	assert String.starts_with?(child["group"], ":")
	assert child["description"]
	end

	test "filters by database configuration whitelist", %{conn: conn} do
	clear_config(:database_config_whitelist, [
	{:pleroma, :instance},
	{:pleroma, :activitypub},
	{:pleroma, Pleroma.Upload},
	{:esshd}
	])

	admin = insert(:user, is_admin: true)

	conn =
	assign(conn, :user, admin)
	\|> get("/api/pleroma/admin/config/descriptions")

	children = json_response_and_validate_schema(conn, 200)

	assert length(children) == 4

	assert Enum.count(children, fn c -> c["group"] == ":pleroma" end) == 3

	instance = Enum.find(children, fn c -> c["key"] == ":instance" end)
	assert instance["children"]

	activitypub = Enum.find(children, fn c -> c["key"] == ":activitypub" end)
	assert activitypub["children"]

	web_endpoint = Enum.find(children, fn c -> c["key"] == "Pleroma.Upload" end)
	assert web_endpoint["children"]

	esshd = Enum.find(children, fn c -> c["group"] == ":esshd" end)
	assert esshd["children"]
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 30, 1:42 PM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1738018
Default Alt Text: (85 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions