No OneTemporary
Actions

Size

117 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/docs/api/admin_api.md b/docs/api/admin_api.md
	index 5dcc8d059..c05a353d7 100644
	--- a/docs/api/admin_api.md
	+++ b/docs/api/admin_api.md
	@@ -1,639 +1,648 @@
	# Admin API

	Authentication is required and the user must be an admin.

	## `/api/pleroma/admin/users`

	### List users

	- Method `GET`
	- Query Params:
	- optional `query`: string search term (e.g. nickname, domain, nickname@domain)
	- optional `filters`: string comma-separated string of filters:
	- `local`: only local users
	- `external`: only external users
	- `active`: only active users
	- `deactivated`: only deactivated users
	- `is_admin`: users with admin role
	- `is_moderator`: users with moderator role
	- optional `page`: integer page number
	- optional `page_size`: integer number of users per page (default is `50`)
	- optional `tags`: [string] tags list
	- optional `name`: string user display name
	- optional `email`: string user email
	- Example: `https://mypleroma.org/api/pleroma/admin/users?query=john&filters=local,active&page=1&page_size=10&tags[]=some_tag&tags[]=another_tag&name=display_name&email=email@example.com`
	- Response:

	```json
	{
	"page_size": integer,
	"count": integer,
	"users": [
	{
	"deactivated": bool,
	"id": integer,
	"nickname": string,
	"roles": {
	"admin": bool,
	"moderator": bool
	},
	"local": bool,
	"tags": array
	},
	...
	]
	}
	```

	## `/api/pleroma/admin/users`

	### Remove a user

	- Method `DELETE`
	- Params:
	- `nickname`
	- Response: User’s nickname

	### Create a user

	- Method: `POST`
	- Params:
	- `nickname`
	- `email`
	- `password`
	- Response: User’s nickname

	## `/api/pleroma/admin/users/follow`
	### Make a user follow another user

	- Methods: `POST`
	- Params:
	- `follower`: The nickname of the follower
	- `followed`: The nickname of the followed
	- Response:
	- "ok"

	## `/api/pleroma/admin/users/unfollow`
	### Make a user unfollow another user

	- Methods: `POST`
	- Params:
	- `follower`: The nickname of the follower
	- `followed`: The nickname of the followed
	- Response:
	- "ok"

	## `/api/pleroma/admin/users/:nickname/toggle_activation`

	### Toggle user activation

	- Method: `PATCH`
	- Params:
	- `nickname`
	- Response: User’s object

	```json
	{
	"deactivated": bool,
	"id": integer,
	"nickname": string
	}
	```

	## `/api/pleroma/admin/users/tag`

	### Tag a list of users

	- Method: `PUT`
	- Params:
	- `nicknames` (array)
	- `tags` (array)

	### Untag a list of users

	- Method: `DELETE`
	- Params:
	- `nicknames` (array)
	- `tags` (array)

	## `/api/pleroma/admin/users/:nickname/permission_group`

	### Get user user permission groups membership

	- Method: `GET`
	- Params: none
	- Response:

	```json
	{
	"is_moderator": bool,
	"is_admin": bool
	}
	```

	## `/api/pleroma/admin/users/:nickname/permission_group/:permission_group`

	Note: Available `:permission_group` is currently moderator and admin. 404 is returned when the permission group doesn’t exist.

	### Get user user permission groups membership per permission group

	- Method: `GET`
	- Params: none
	- Response:

	```json
	{
	"is_moderator": bool,
	"is_admin": bool
	}
	```

	### Add user in permission group

	- Method: `POST`
	- Params: none
	- Response:
	- On failure: `{"error": "…"}`
	- On success: JSON of the `user.info`

	### Remove user from permission group

	- Method: `DELETE`
	- Params: none
	- Response:
	- On failure: `{"error": "…"}`
	- On success: JSON of the `user.info`
	- Note: An admin cannot revoke their own admin status.

	## `/api/pleroma/admin/users/:nickname/activation_status`

	### Active or deactivate a user

	- Method: `PUT`
	- Params:
	- `nickname`
	- `status` BOOLEAN field, false value means deactivation.

	## `/api/pleroma/admin/users/:nickname`

	### Retrive the details of a user

	- Method: `GET`
	- Params:
	- `nickname`
	- Response:
	- On failure: `Not found`
	- On success: JSON of the user

	## `/api/pleroma/admin/relay`

	### Follow a Relay

	- Methods: `POST`
	- Params:
	- `relay_url`
	- Response:
	- On success: URL of the followed relay

	### Unfollow a Relay

	- Methods: `DELETE`
	- Params:
	- `relay_url`
	- Response:
	- On success: URL of the unfollowed relay

	## `/api/pleroma/admin/users/invite_token`

	### Get an account registration invite token

	- Methods: `GET`
	- Params:
	- optional `invite` => [
	- optional `max_use` (integer)
	- optional `expires_at` (date string e.g. "2019-04-07")
	]
	- Response: invite token (base64 string)

	## `/api/pleroma/admin/users/invites`

	### Get a list of generated invites

	- Methods: `GET`
	- Params: none
	- Response:

	```json
	{

	"invites": [
	{
	"id": integer,
	"token": string,
	"used": boolean,
	"expires_at": date,
	"uses": integer,
	"max_use": integer,
	"invite_type": string (possible values: `one_time`, `reusable`, `date_limited`, `reusable_date_limited`)
	},
	...
	]
	}
	```

	## `/api/pleroma/admin/users/revoke_invite`

	### Revoke invite by token

	- Methods: `POST`
	- Params:
	- `token`
	- Response:

	```json
	{
	"id": integer,
	"token": string,
	"used": boolean,
	"expires_at": date,
	"uses": integer,
	"max_use": integer,
	"invite_type": string (possible values: `one_time`, `reusable`, `date_limited`, `reusable_date_limited`)

	}
	```


	## `/api/pleroma/admin/users/email_invite`

	### Sends registration invite via email

	- Methods: `POST`
	- Params:
	- `email`
	- `name`, optional

	## `/api/pleroma/admin/users/:nickname/password_reset`

	### Get a password reset token for a given nickname

	- Methods: `GET`
	- Params: none
	- Response: password reset token (base64 string)

	## `/api/pleroma/admin/reports`
	### Get a list of reports
	- Method `GET`
	- Params:
	- `state`: optional, the state of reports. Valid values are `open`, `closed` and `resolved`
	- `limit`: optional, the number of records to retrieve
	- `since_id`: optional, returns results that are more recent than the specified id
	- `max_id`: optional, returns results that are older than the specified id
	- Response:
	- On failure: 403 Forbidden error `{"error": "error_msg"}` when requested by anonymous or non-admin
	- On success: JSON, returns a list of reports, where:
	- `account`: the user who has been reported
	- `actor`: the user who has sent the report
	- `statuses`: list of statuses that have been included to the report

	```json
	{
	"reports": [
	{
	"account": {
	"acct": "user",
	"avatar": "https://pleroma.example.org/images/avi.png",
	"avatar_static": "https://pleroma.example.org/images/avi.png",
	"bot": false,
	"created_at": "2019-04-23T17:32:04.000Z",
	"display_name": "User",
	"emojis": [],
	"fields": [],
	"followers_count": 1,
	"following_count": 1,
	"header": "https://pleroma.example.org/images/banner.png",
	"header_static": "https://pleroma.example.org/images/banner.png",
	"id": "9i6dAJqSGSKMzLG2Lo",
	"locked": false,
	"note": "",
	"pleroma": {
	"confirmation_pending": false,
	"hide_favorites": true,
	"hide_followers": false,
	"hide_follows": false,
	"is_admin": false,
	"is_moderator": false,
	"relationship": {},
	"tags": []
	},
	"source": {
	"note": "",
	"pleroma": {},
	"sensitive": false
	},
	"statuses_count": 3,
	"url": "https://pleroma.example.org/users/user",
	"username": "user"
	},
	"actor": {
	"acct": "lain",
	"avatar": "https://pleroma.example.org/images/avi.png",
	"avatar_static": "https://pleroma.example.org/images/avi.png",
	"bot": false,
	"created_at": "2019-03-28T17:36:03.000Z",
	"display_name": "Roger Braun",
	"emojis": [],
	"fields": [],
	"followers_count": 1,
	"following_count": 1,
	"header": "https://pleroma.example.org/images/banner.png",
	"header_static": "https://pleroma.example.org/images/banner.png",
	"id": "9hEkA5JsvAdlSrocam",
	"locked": false,
	"note": "",
	"pleroma": {
	"confirmation_pending": false,
	"hide_favorites": false,
	"hide_followers": false,
	"hide_follows": false,
	"is_admin": false,
	"is_moderator": false,
	"relationship": {},
	"tags": []
	},
	"source": {
	"note": "",
	"pleroma": {},
	"sensitive": false
	},
	"statuses_count": 1,
	"url": "https://pleroma.example.org/users/lain",
	"username": "lain"
	},
	"content": "Please delete it",
	"created_at": "2019-04-29T19:48:15.000Z",
	"id": "9iJGOv1j8hxuw19bcm",
	"state": "open",
	"statuses": [
	{
	"account": { ... },
	"application": {
	"name": "Web",
	"website": null
	},
	"bookmarked": false,
	"card": null,
	"content": "<span class=\"h-card\"><a data-user=\"9hEkA5JsvAdlSrocam\" class=\"u-url mention\" href=\"https://pleroma.example.org/users/lain\">@<span>lain</span></a></span> click on my link <a href=\"https://www.google.com/\">https://www.google.com/</a>",
	"created_at": "2019-04-23T19:15:47.000Z",
	"emojis": [],
	"favourited": false,
	"favourites_count": 0,
	"id": "9i6mQ9uVrrOmOime8m",
	"in_reply_to_account_id": null,
	"in_reply_to_id": null,
	"language": null,
	"media_attachments": [],
	"mentions": [
	{
	"acct": "lain",
	"id": "9hEkA5JsvAdlSrocam",
	"url": "https://pleroma.example.org/users/lain",
	"username": "lain"
	},
	{
	"acct": "user",
	"id": "9i6dAJqSGSKMzLG2Lo",
	"url": "https://pleroma.example.org/users/user",
	"username": "user"
	}
	],
	"muted": false,
	"pinned": false,
	"pleroma": {
	"content": {
	"text/plain": "@lain click on my link https://www.google.com/"
	},
	"conversation_id": 28,
	"in_reply_to_account_acct": null,
	"local": true,
	"spoiler_text": {
	"text/plain": ""
	}
	},
	"reblog": null,
	"reblogged": false,
	"reblogs_count": 0,
	"replies_count": 0,
	"sensitive": false,
	"spoiler_text": "",
	"tags": [],
	"uri": "https://pleroma.example.org/objects/8717b90f-8e09-4b58-97b0-e3305472b396",
	"url": "https://pleroma.example.org/notice/9i6mQ9uVrrOmOime8m",
	"visibility": "direct"
	}
	]
	}
	]
	}
	```

	## `/api/pleroma/admin/reports/:id`
	### Get an individual report
	- Method `GET`
	- Params:
	- `id`
	- Response:
	- On failure:
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, Report object (see above)

	## `/api/pleroma/admin/reports/:id`
	### Change the state of the report
	- Method `PUT`
	- Params:
	- `id`
	- `state`: required, the new state. Valid values are `open`, `closed` and `resolved`
	- Response:
	- On failure:
	- 400 Bad Request `"Unsupported state"`
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, Report object (see above)

	## `/api/pleroma/admin/reports/:id/respond`
	### Respond to a report
	- Method `POST`
	- Params:
	- `id`
	- `status`: required, the message
	- Response:
	- On failure:
	- 400 Bad Request `"Invalid parameters"` when `status` is missing
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, created Mastodon Status entity

	```json
	{
	"account": { ... },
	"application": {
	"name": "Web",
	"website": null
	},
	"bookmarked": false,
	"card": null,
	"content": "Your claim is going to be closed",
	"created_at": "2019-05-11T17:13:03.000Z",
	"emojis": [],
	"favourited": false,
	"favourites_count": 0,
	"id": "9ihuiSL1405I65TmEq",
	"in_reply_to_account_id": null,
	"in_reply_to_id": null,
	"language": null,
	"media_attachments": [],
	"mentions": [
	{
	"acct": "user",
	"id": "9i6dAJqSGSKMzLG2Lo",
	"url": "https://pleroma.example.org/users/user",
	"username": "user"
	},
	{
	"acct": "admin",
	"id": "9hEkA5JsvAdlSrocam",
	"url": "https://pleroma.example.org/users/admin",
	"username": "admin"
	}
	],
	"muted": false,
	"pinned": false,
	"pleroma": {
	"content": {
	"text/plain": "Your claim is going to be closed"
	},
	"conversation_id": 35,
	"in_reply_to_account_acct": null,
	"local": true,
	"spoiler_text": {
	"text/plain": ""
	}
	},
	"reblog": null,
	"reblogged": false,
	"reblogs_count": 0,
	"replies_count": 0,
	"sensitive": false,
	"spoiler_text": "",
	"tags": [],
	"uri": "https://pleroma.example.org/objects/cab0836d-9814-46cd-a0ea-529da9db5fcb",
	"url": "https://pleroma.example.org/notice/9ihuiSL1405I65TmEq",
	"visibility": "direct"
	}
	```

	## `/api/pleroma/admin/statuses/:id`
	### Change the scope of an individual reported status
	- Method `PUT`
	- Params:
	- `id`
	- `sensitive`: optional, valid values are `true` or `false`
	- `visibility`: optional, valid values are `public`, `private` and `unlisted`
	- Response:
	- On failure:
	- 400 Bad Request `"Unsupported visibility"`
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, Mastodon Status entity

	## `/api/pleroma/admin/statuses/:id`
	### Delete an individual reported status
	- Method `DELETE`
	- Params:
	- `id`
	- Response:
	- On failure:
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: 200 OK `{}`

	## `/api/pleroma/admin/config`
	### List config settings
	- Method `GET`
	- Params: none
	- Response:

	```json
	{
	configs: [
	{
	+ "group": string,
	"key": string,
	- "value": string or {} or []
	+ "value": string or {} or [] or {"tuple": []}
	}
	]
	}
	```

	## `/api/pleroma/admin/config`
	### Update config settings
	Module name can be passed as string, which starts with `Pleroma`, e.g. `"Pleroma.Upload"`.
	Atom or boolean value can be passed with `:` in the beginning, e.g. `":true"`, `":upload"`.
	Integer with `i:`, e.g. `"i:150"`.
	+Tuple with more than 2 values with `{"tuple": ["first_val", Pleroma.Module, []]}`.
	+`{"tuple": ["some_string", "Pleroma.Some.Module", []]}` will be converted to `{"some_string", Pleroma.Some.Module, []}`.

	Compile time settings (need instance reboot):
	- all settings by this keys:
	- `:hackney_pools`
	- `:chat`
	- `Pleroma.Web.Endpoint`
	- `Pleroma.Repo`
	- part settings:
	- `Pleroma.Captcha` -> `:seconds_valid`
	- `Pleroma.Upload` -> `:proxy_remote`
	- `:instance` -> `:upload_limit`

	- Method `POST`
	- Params:
	- `configs` => [
	+ - `group` (string)
	- `key` (string)
	- - `value` (string, [], {})
	+ - `value` (string, [], {} or {"tuple": []})
	- `delete` = true (optional, if parameter must be deleted)
	]

	- Request (example):

	```json
	{
	configs: [
	{
	+ "group": "pleroma",
	"key": "Pleroma.Upload",
	"value": {
	"uploader": "Pleroma.Uploaders.Local",
	"filters": ["Pleroma.Upload.Filter.Dedupe"],
	"link_name": ":true",
	"proxy_remote": ":false",
	"proxy_opts": {
	"redirect_on_failure": ":false",
	"max_body_length": "i:1048576",
	"http": {
	"follow_redirect": ":true",
	"pool": ":upload"
	}
	+ },
	+ "dispatch": {
	+ "tuple": ["/api/v1/streaming", "Pleroma.Web.MastodonAPI.WebsocketHandler", []]
	}
	}
	}
	]
	}

	- Response:

	```json
	{
	configs: [
	{
	+ "group": string,
	"key": string,
	- "value": string or {} or []
	+ "value": string or {} or [] or {"tuple": []}
	}
	]
	}
	```
	diff --git a/lib/mix/tasks/pleroma/config.ex b/lib/mix/tasks/pleroma/config.ex
	index cc5425362..4ed2c9789 100644
	--- a/lib/mix/tasks/pleroma/config.ex
	+++ b/lib/mix/tasks/pleroma/config.ex
	@@ -1,69 +1,71 @@
	defmodule Mix.Tasks.Pleroma.Config do
	use Mix.Task
	import Mix.Pleroma
	alias Pleroma.Repo
	alias Pleroma.Web.AdminAPI.Config
	@shortdoc "Manages the location of the config"
	@moduledoc """
	Manages the location of the config.

	## Transfers config from file to DB.

	mix pleroma.config migrate_to_db

	## Transfers config from DB to file.

	mix pleroma.config migrate_from_db ENV
	"""

	def run(["migrate_to_db"]) do
	start_pleroma()

	if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	Application.get_all_env(:pleroma)
	\|> Enum.reject(fn {k, _v} -> k in [Pleroma.Repo, :env] end)
	\|> Enum.each(fn {k, v} ->
	key = to_string(k) \|> String.replace("Elixir.", "")
	- {:ok, _} = Config.update_or_create(%{key: key, value: v})
	+ {:ok, _} = Config.update_or_create(%{group: "pleroma", key: key, value: v})
	Mix.shell().info("#{key} is migrated.")
	end)

	Mix.shell().info("Settings migrated.")
	else
	Mix.shell().info(
	"Migration is not allowed by config. You can change this behavior in instance settings."
	)
	end
	end

	def run(["migrate_from_db", env]) do
	start_pleroma()

	if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	config_path = "config/#{env}.exported_from_db.secret.exs"

	{:ok, file} = File.open(config_path, [:write])
	IO.write(file, "use Mix.Config\r\n")

	Repo.all(Config)
	\|> Enum.each(fn config ->
	mark = if String.starts_with?(config.key, "Pleroma."), do: ",", else: ":"

	IO.write(
	file,
	- "config :pleroma, #{config.key}#{mark} #{inspect(Config.from_binary(config.value))}\r\n"
	+ "config :#{config.group}, #{config.key}#{mark} #{
	+ inspect(Config.from_binary(config.value))
	+ }\r\n"
	)

	{:ok, _} = Repo.delete(config)
	Mix.shell().info("#{config.key} deleted from DB.")
	end)

	File.close(file)
	System.cmd("mix", ["format", config_path])
	else
	Mix.shell().info(
	"Migration is not allowed by config. You can change this behavior in instance settings."
	)
	end
	end
	end
	diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
	index a8cbfa52a..cf880aa22 100644
	--- a/lib/pleroma/config/transfer_task.ex
	+++ b/lib/pleroma/config/transfer_task.ex
	@@ -1,42 +1,55 @@
	defmodule Pleroma.Config.TransferTask do
	use Task
	alias Pleroma.Web.AdminAPI.Config

	def start_link do
	load_and_update_env()
	if Pleroma.Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Pleroma.Repo)
	:ignore
	end

	def load_and_update_env do
	if Pleroma.Config.get([:instance, :dynamic_configuration]) and
	Ecto.Adapters.SQL.table_exists?(Pleroma.Repo, "config") do
	- Pleroma.Repo.all(Config)
	- \|> Enum.each(&update_env(&1))
	+ for_restart =
	+ Pleroma.Repo.all(Config)
	+ \|> Enum.map(&update_env(&1))
	+
	+ # We need to restart applications for loaded settings take effect
	+ for_restart
	+ \|> Enum.reject(&(&1 in [:pleroma, :ok]))
	+ \|> Enum.each(fn app ->
	+ Application.stop(app)
	+ :ok = Application.start(app)
	+ end)
	end
	end

	defp update_env(setting) do
	try do
	key =
	if String.starts_with?(setting.key, "Pleroma.") do
	"Elixir." <> setting.key
	else
	setting.key
	end

	+ group = String.to_existing_atom(setting.group)
	+
	Application.put_env(
	- :pleroma,
	+ group,
	String.to_existing_atom(key),
	Config.from_binary(setting.value)
	)
	+
	+ group
	rescue
	e ->
	require Logger

	Logger.warn(
	"updating env causes error, key: #{inspect(setting.key)}, error: #{inspect(e)}"
	)
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/admin_api_controller.ex
	index 03dfdca82..953a22ea0 100644
	--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
	+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
	@@ -1,447 +1,447 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIController do
	use Pleroma.Web, :controller
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.AdminAPI.Config
	alias Pleroma.Web.AdminAPI.ConfigView
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.AdminAPI.Search
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.StatusView

	import Pleroma.Web.ControllerHelper, only: [json_response: 3]

	require Logger

	@users_page_size 50

	action_fallback(:errors)

	def user_delete(conn, %{"nickname" => nickname}) do
	User.get_cached_by_nickname(nickname)
	\|> User.delete()

	conn
	\|> json(nickname)
	end

	def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.follow(follower, followed)
	end

	conn
	\|> json("ok")
	end

	def user_unfollow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.unfollow(follower, followed)
	end

	conn
	\|> json("ok")
	end

	def user_create(
	conn,
	%{"nickname" => nickname, "email" => email, "password" => password}
	) do
	user_data = %{
	nickname: nickname,
	name: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	bio: "."
	}

	changeset = User.register_changeset(%User{}, user_data, need_confirmation: false)
	{:ok, user} = User.register(changeset)

	conn
	\|> json(user.nickname)
	end

	def user_show(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> json(AccountView.render("show.json", %{user: user}))
	else
	_ -> {:error, :not_found}
	end
	end

	def user_toggle_activation(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)

	{:ok, updated_user} = User.deactivate(user, !user.info.deactivated)

	conn
	\|> json(AccountView.render("show.json", %{user: updated_user}))
	end

	def tag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.tag(nicknames, tags),
	do: json_response(conn, :no_content, "")
	end

	def untag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.untag(nicknames, tags),
	do: json_response(conn, :no_content, "")
	end

	def list_users(conn, params) do
	{page, page_size} = page_params(params)
	filters = maybe_parse_filters(params["filters"])

	search_params = %{
	query: params["query"],
	page: page,
	page_size: page_size,
	tags: params["tags"],
	name: params["name"],
	email: params["email"]
	}

	with {:ok, users, count} <- Search.user(Map.merge(search_params, filters)),
	do:
	conn
	\|> json(
	AccountView.render("index.json",
	users: users,
	count: count,
	page_size: page_size
	)
	)
	end

	@filters ~w(local external active deactivated is_admin is_moderator)

	@spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} \| %{}
	defp maybe_parse_filters(filters) when is_nil(filters) or filters == "", do: %{}

	defp maybe_parse_filters(filters) do
	filters
	\|> String.split(",")
	\|> Enum.filter(&Enum.member?(@filters, &1))
	\|> Enum.map(&String.to_atom(&1))
	\|> Enum.into(%{}, &{&1, true})
	end

	def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname})
	when permission_group in ["moderator", "admin"] do
	user = User.get_cached_by_nickname(nickname)

	info =
	%{}
	\|> Map.put("is_" <> permission_group, true)

	info_cng = User.Info.admin_api_update(user.info, info)

	cng =
	user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, info_cng)

	{:ok, _user} = User.update_and_set_cache(cng)

	json(conn, info)
	end

	def right_add(conn, _) do
	conn
	\|> put_status(404)
	\|> json(%{error: "No such permission_group"})
	end

	def right_get(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)

	conn
	\|> json(%{
	is_moderator: user.info.is_moderator,
	is_admin: user.info.is_admin
	})
	end

	def right_delete(
	%{assigns: %{user: %User{:nickname => admin_nickname}}} = conn,
	%{
	"permission_group" => permission_group,
	"nickname" => nickname
	}
	)
	when permission_group in ["moderator", "admin"] do
	if admin_nickname == nickname do
	conn
	\|> put_status(403)
	\|> json(%{error: "You can't revoke your own admin status."})
	else
	user = User.get_cached_by_nickname(nickname)

	info =
	%{}
	\|> Map.put("is_" <> permission_group, false)

	info_cng = User.Info.admin_api_update(user.info, info)

	cng =
	Ecto.Changeset.change(user)
	\|> Ecto.Changeset.put_embed(:info, info_cng)

	{:ok, _user} = User.update_and_set_cache(cng)

	json(conn, info)
	end
	end

	def right_delete(conn, _) do
	conn
	\|> put_status(404)
	\|> json(%{error: "No such permission_group"})
	end

	def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do
	with {:ok, status} <- Ecto.Type.cast(:boolean, status),
	%User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, _} <- User.deactivate(user, !status),
	do: json_response(conn, :no_content, "")
	end

	def relay_follow(conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.follow(target) do
	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	def relay_unfollow(conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.unfollow(target) do
	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	@doc "Sends registration invite via email"
	def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
	with true <-
	Pleroma.Config.get([:instance, :invites_enabled]) &&
	!Pleroma.Config.get([:instance, :registrations_open]),
	{:ok, invite_token} <- UserInviteToken.create_invite(),
	email <-
	Pleroma.Emails.UserEmail.user_invitation_email(
	user,
	invite_token,
	email,
	params["name"]
	),
	{:ok, _} <- Pleroma.Emails.Mailer.deliver(email) do
	json_response(conn, :no_content, "")
	end
	end

	@doc "Get a account registeration invite token (base64 string)"
	def get_invite_token(conn, params) do
	options = params["invite"] \|\| %{}
	{:ok, invite} = UserInviteToken.create_invite(options)

	conn
	\|> json(invite.token)
	end

	@doc "Get list of created invites"
	def invites(conn, _params) do
	invites = UserInviteToken.list_invites()

	conn
	\|> json(AccountView.render("invites.json", %{invites: invites}))
	end

	@doc "Revokes invite by token"
	def revoke_invite(conn, %{"token" => token}) do
	invite = UserInviteToken.find_by_token!(token)
	{:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true})

	conn
	\|> json(AccountView.render("invite.json", %{invite: updated_invite}))
	end

	@doc "Get a password reset token (base64 string) for given nickname"
	def get_password_reset(conn, %{"nickname" => nickname}) do
	(%User{local: true} = user) = User.get_cached_by_nickname(nickname)
	{:ok, token} = Pleroma.PasswordResetToken.create_token(user)

	conn
	\|> json(token.token)
	end

	def list_reports(conn, params) do
	params =
	params
	\|> Map.put("type", "Flag")
	\|> Map.put("skip_preload", true)

	reports =
	[]
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> put_view(ReportView)
	\|> render("index.json", %{reports: reports})
	end

	def report_show(conn, %{"id" => id}) do
	with %Activity{} = report <- Activity.get_by_id(id) do
	conn
	\|> put_view(ReportView)
	\|> render("show.json", %{report: report})
	else
	_ -> {:error, :not_found}
	end
	end

	def report_update_state(conn, %{"id" => id, "state" => state}) do
	with {:ok, report} <- CommonAPI.update_report_state(id, state) do
	conn
	\|> put_view(ReportView)
	\|> render("show.json", %{report: report})
	end
	end

	def report_respond(%{assigns: %{user: user}} = conn, %{"id" => id} = params) do
	with false <- is_nil(params["status"]),
	%Activity{} <- Activity.get_by_id(id) do
	params =
	params
	\|> Map.put("in_reply_to_status_id", id)
	\|> Map.put("visibility", "direct")

	{:ok, activity} = CommonAPI.post(user, params)

	conn
	\|> put_view(StatusView)
	\|> render("status.json", %{activity: activity})
	else
	true ->
	{:param_cast, nil}

	nil ->
	{:error, :not_found}
	end
	end

	def status_update(conn, %{"id" => id} = params) do
	with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do
	conn
	\|> put_view(StatusView)
	\|> render("status.json", %{activity: activity})
	end
	end

	def status_delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	json(conn, %{})
	end
	end

	def config_show(conn, _params) do
	configs = Pleroma.Repo.all(Config)

	conn
	\|> put_view(ConfigView)
	\|> render("index.json", %{configs: configs})
	end

	def config_update(conn, %{"configs" => configs}) do
	updated =
	if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	updated =
	Enum.map(configs, fn
	- %{"key" => key, "value" => value} ->
	- {:ok, config} = Config.update_or_create(%{key: key, value: value})
	+ %{"group" => group, "key" => key, "value" => value} ->
	+ {:ok, config} = Config.update_or_create(%{group: group, key: key, value: value})
	config

	- %{"key" => key, "delete" => "true"} ->
	- {:ok, _} = Config.delete(key)
	+ %{"group" => group, "key" => key, "delete" => "true"} ->
	+ {:ok, _} = Config.delete(%{group: group, key: key})
	nil
	end)
	\|> Enum.reject(&is_nil(&1))

	Pleroma.Config.TransferTask.load_and_update_env()
	Mix.Tasks.Pleroma.Config.run(["migrate_from_db", Pleroma.Config.get(:env)])
	updated
	else
	[]
	end

	conn
	\|> put_view(ConfigView)
	\|> render("index.json", %{configs: updated})
	end

	def errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(404)
	\|> json("Not found")
	end

	def errors(conn, {:error, reason}) do
	conn
	\|> put_status(400)
	\|> json(reason)
	end

	def errors(conn, {:param_cast, _}) do
	conn
	\|> put_status(400)
	\|> json("Invalid parameters")
	end

	def errors(conn, _) do
	conn
	\|> put_status(500)
	\|> json("Something went wrong")
	end

	defp page_params(params) do
	{get_page(params["page"]), get_page_size(params["page_size"])}
	end

	defp get_page(page_string) when is_nil(page_string), do: 1

	defp get_page(page_string) do
	case Integer.parse(page_string) do
	{page, _} -> page
	:error -> 1
	end
	end

	defp get_page_size(page_size_string) when is_nil(page_size_string), do: @users_page_size

	defp get_page_size(page_size_string) do
	case Integer.parse(page_size_string) do
	{page_size, _} -> page_size
	:error -> @users_page_size
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/config.ex b/lib/pleroma/web/admin_api/config.ex
	index b7072f050..8b9b658a9 100644
	--- a/lib/pleroma/web/admin_api/config.ex
	+++ b/lib/pleroma/web/admin_api/config.ex
	@@ -1,144 +1,160 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.Config do
	use Ecto.Schema
	import Ecto.Changeset
	alias __MODULE__
	alias Pleroma.Repo

	@type t :: %__MODULE__{}

	schema "config" do
	field(:key, :string)
	+ field(:group, :string)
	field(:value, :binary)

	timestamps()
	end

	- @spec get_by_key(String.t()) :: Config.t() \| nil
	- def get_by_key(key), do: Repo.get_by(Config, key: key)
	+ @spec get_by_params(map()) :: Config.t() \| nil
	+ def get_by_params(params), do: Repo.get_by(Config, params)

	@spec changeset(Config.t(), map()) :: Changeset.t()
	def changeset(config, params \\ %{}) do
	config
	- \|> cast(params, [:key, :value])
	- \|> validate_required([:key, :value])
	- \|> unique_constraint(:key)
	+ \|> cast(params, [:key, :group, :value])
	+ \|> validate_required([:key, :group, :value])
	+ \|> unique_constraint(:key, name: :config_group_key_index)
	end

	@spec create(map()) :: {:ok, Config.t()} \| {:error, Changeset.t()}
	- def create(%{key: key, value: value}) do
	+ def create(params) do
	%Config{}
	- \|> changeset(%{key: key, value: transform(value)})
	+ \|> changeset(Map.put(params, :value, transform(params[:value])))
	\|> Repo.insert()
	end

	@spec update(Config.t(), map()) :: {:ok, Config} \| {:error, Changeset.t()}
	def update(%Config{} = config, %{value: value}) do
	config
	\|> change(value: transform(value))
	\|> Repo.update()
	end

	@spec update_or_create(map()) :: {:ok, Config.t()} \| {:error, Changeset.t()}
	- def update_or_create(%{key: key} = params) do
	- with %Config{} = config <- Config.get_by_key(key) do
	+ def update_or_create(params) do
	+ with %Config{} = config <- Config.get_by_params(Map.take(params, [:group, :key])) do
	Config.update(config, params)
	else
	nil -> Config.create(params)
	end
	end

	- @spec delete(String.t()) :: {:ok, Config.t()} \| {:error, Changeset.t()}
	- def delete(key) do
	- with %Config{} = config <- Config.get_by_key(key) do
	+ @spec delete(map()) :: {:ok, Config.t()} \| {:error, Changeset.t()}
	+ def delete(params) do
	+ with %Config{} = config <- Config.get_by_params(params) do
	Repo.delete(config)
	else
	- nil -> {:error, "Config with key #{key} not found"}
	+ nil -> {:error, "Config with params #{inspect(params)} not found"}
	end
	end

	@spec from_binary(binary()) :: term()
	def from_binary(value), do: :erlang.binary_to_term(value)

	@spec from_binary_to_map(binary()) :: any()
	def from_binary_to_map(binary) do
	from_binary(binary)
	\|> do_convert()
	end

	defp do_convert([{k, v}] = value) when is_list(value) and length(value) == 1,
	do: %{k => do_convert(v)}

	defp do_convert(values) when is_list(values), do: for(val <- values, do: do_convert(val))

	defp do_convert({k, v} = value) when is_tuple(value),
	do: %{k => do_convert(v)}

	- defp do_convert(value) when is_binary(value) or is_atom(value) or is_map(value),
	- do: value
	+ defp do_convert(value) when is_tuple(value), do: %{"tuple" => do_convert(Tuple.to_list(value))}
	+
	+ defp do_convert(value) when is_binary(value) or is_map(value) or is_number(value), do: value
	+
	+ defp do_convert(value) when is_atom(value) do
	+ string = to_string(value)
	+
	+ if String.starts_with?(string, "Elixir."),
	+ do: String.trim_leading(string, "Elixir."),
	+ else: value
	+ end

	@spec transform(any()) :: binary()
	+ def transform(%{"tuple" => _} = entity), do: :erlang.term_to_binary(do_transform(entity))
	+
	def transform(entity) when is_map(entity) do
	tuples =
	for {k, v} <- entity,
	into: [],
	do: {if(is_atom(k), do: k, else: String.to_atom(k)), do_transform(v)}

	Enum.reject(tuples, fn {_k, v} -> is_nil(v) end)
	\|> Enum.sort()
	\|> :erlang.term_to_binary()
	end

	def transform(entity) when is_list(entity) do
	list = Enum.map(entity, &do_transform(&1))
	:erlang.term_to_binary(list)
	end

	def transform(entity), do: :erlang.term_to_binary(entity)

	defp do_transform(%Regex{} = value) when is_map(value), do: value

	+ defp do_transform(%{"tuple" => [k, values] = entity}) when length(entity) == 2 do
	+ {do_transform(k), do_transform(values)}
	+ end
	+
	+ defp do_transform(%{"tuple" => values}) do
	+ Enum.reduce(values, {}, fn val, acc -> Tuple.append(acc, do_transform(val)) end)
	+ end
	+
	defp do_transform(value) when is_map(value) do
	- values =
	- for {key, val} <- value,
	- into: [],
	- do: {String.to_atom(key), do_transform(val)}
	+ values = for {key, val} <- value, into: [], do: {String.to_atom(key), do_transform(val)}

	Enum.sort(values)
	end

	defp do_transform(value) when is_list(value) do
	Enum.map(value, &do_transform(&1))
	end

	defp do_transform(entity) when is_list(entity) and length(entity) == 1, do: hd(entity)

	defp do_transform(value) when is_binary(value) do
	- value = String.trim(value)
	+ String.trim(value)
	+ \|> do_transform_string()
	+ end

	- case String.length(value) do
	- 0 ->
	- nil
	+ defp do_transform(value), do: value

	- _ ->
	- cond do
	- String.starts_with?(value, "Pleroma") ->
	- String.to_existing_atom("Elixir." <> value)
	+ defp do_transform_string(value) when byte_size(value) == 0, do: nil

	- String.starts_with?(value, ":") ->
	- String.replace(value, ":", "") \|> String.to_existing_atom()
	+ defp do_transform_string(value) do
	+ cond do
	+ String.starts_with?(value, "Pleroma") or String.starts_with?(value, "Phoenix") ->
	+ String.to_existing_atom("Elixir." <> value)

	- String.starts_with?(value, "i:") ->
	- String.replace(value, "i:", "") \|> String.to_integer()
	+ String.starts_with?(value, ":") ->
	+ String.replace(value, ":", "") \|> String.to_existing_atom()

	- true ->
	- value
	- end
	+ String.starts_with?(value, "i:") ->
	+ String.replace(value, "i:", "") \|> String.to_integer()
	+
	+ true ->
	+ value
	end
	end
	-
	- defp do_transform(value), do: value
	end
	diff --git a/lib/pleroma/web/admin_api/views/config_view.ex b/lib/pleroma/web/admin_api/views/config_view.ex
	index c8560033e..3ccc9ca46 100644
	--- a/lib/pleroma/web/admin_api/views/config_view.ex
	+++ b/lib/pleroma/web/admin_api/views/config_view.ex
	@@ -1,16 +1,17 @@
	defmodule Pleroma.Web.AdminAPI.ConfigView do
	use Pleroma.Web, :view

	def render("index.json", %{configs: configs}) do
	%{
	configs: render_many(configs, __MODULE__, "show.json", as: :config)
	}
	end

	def render("show.json", %{config: config}) do
	%{
	key: config.key,
	+ group: config.group,
	value: Pleroma.Web.AdminAPI.Config.from_binary_to_map(config.value)
	}
	end
	end
	diff --git a/priv/repo/migrations/20190622151019_add_group_key_to_config.exs b/priv/repo/migrations/20190622151019_add_group_key_to_config.exs
	new file mode 100644
	index 000000000..d7a3785d0
	--- /dev/null
	+++ b/priv/repo/migrations/20190622151019_add_group_key_to_config.exs
	@@ -0,0 +1,12 @@
	+defmodule Pleroma.Repo.Migrations.AddGroupKeyToConfig do
	+ use Ecto.Migration
	+
	+ def change do
	+ alter table("config") do
	+ add(:group, :string)
	+ end
	+
	+ drop(unique_index("config", :key))
	+ create(unique_index("config", [:group, :key]))
	+ end
	+end
	diff --git a/test/config/transfer_task_test.exs b/test/config/transfer_task_test.exs
	index 9b8a8dd45..c0e433263 100644
	--- a/test/config/transfer_task_test.exs
	+++ b/test/config/transfer_task_test.exs
	@@ -1,35 +1,53 @@
	defmodule Pleroma.Config.TransferTaskTest do
	use Pleroma.DataCase

	setup do
	dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])

	Pleroma.Config.put([:instance, :dynamic_configuration], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
	end)
	end

	test "transfer config values from db to env" do
	refute Application.get_env(:pleroma, :test_key)
	- Pleroma.Web.AdminAPI.Config.create(%{key: "test_key", value: [live: 2, com: 3]})
	+ refute Application.get_env(:idna, :test_key)
	+
	+ Pleroma.Web.AdminAPI.Config.create(%{
	+ group: "pleroma",
	+ key: "test_key",
	+ value: [live: 2, com: 3]
	+ })
	+
	+ Pleroma.Web.AdminAPI.Config.create(%{
	+ group: "idna",
	+ key: "test_key",
	+ value: [live: 15, com: 35]
	+ })

	Pleroma.Config.TransferTask.start_link()

	assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
	+ assert Application.get_env(:idna, :test_key) == [live: 15, com: 35]

	on_exit(fn ->
	Application.delete_env(:pleroma, :test_key)
	+ Application.delete_env(:idna, :test_key)
	end)
	end

	test "non existing atom" do
	- Pleroma.Web.AdminAPI.Config.create(%{key: "undefined_atom_key", value: [live: 2, com: 3]})
	+ Pleroma.Web.AdminAPI.Config.create(%{
	+ group: "pleroma",
	+ key: "undefined_atom_key",
	+ value: [live: 2, com: 3]
	+ })

	assert ExUnit.CaptureLog.capture_log(fn ->
	Pleroma.Config.TransferTask.start_link()
	end) =~
	"updating env causes error, key: \"undefined_atom_key\", error: %ArgumentError{message: \"argument error\"}"
	end
	end
	diff --git a/test/support/factory.ex b/test/support/factory.ex
	index 5be34660e..c2812e8f7 100644
	--- a/test/support/factory.ex
	+++ b/test/support/factory.ex
	@@ -1,326 +1,327 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Factory do
	use ExMachina.Ecto, repo: Pleroma.Repo
	alias Pleroma.User

	def participation_factory do
	conversation = insert(:conversation)
	user = insert(:user)

	%Pleroma.Conversation.Participation{
	conversation: conversation,
	user: user,
	read: false
	}
	end

	def conversation_factory do
	%Pleroma.Conversation{
	ap_id: sequence(:ap_id, &"https://some_conversation/#{&1}")
	}
	end

	def user_factory do
	user = %User{
	name: sequence(:name, &"Test テスト User #{&1}"),
	email: sequence(:email, &"user#{&1}@example.com"),
	nickname: sequence(:nickname, &"nick#{&1}"),
	password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
	bio: sequence(:bio, &"Tester Number #{&1}"),
	info: %{}
	}

	%{
	user
	\| ap_id: User.ap_id(user),
	follower_address: User.ap_followers(user),
	following: [User.ap_id(user)]
	}
	end

	def note_factory(attrs \\ %{}) do
	text = sequence(:text, &"This is :moominmamma: note #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Note",
	"content" => text,
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"likes" => [],
	"like_count" => 0,
	"context" => "2hu",
	"summary" => "2hu",
	"tag" => ["2hu"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def direct_note_factory do
	user2 = insert(:user)

	%Pleroma.Object{data: data} = note_factory()
	%Pleroma.Object{data: Map.merge(data, %{"to" => [user2.ap_id]})}
	end

	def article_factory do
	note_factory()
	\|> Map.put("type", "Article")
	end

	def tombstone_factory do
	data = %{
	"type" => "Tombstone",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"formerType" => "Note",
	"deleted" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Object{
	data: data
	}
	end

	def direct_note_activity_factory do
	dm = insert(:direct_note)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => dm.data["actor"],
	"to" => dm.data["to"],
	"object" => dm.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => dm.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def note_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	note = attrs[:note] \|\| insert(:note, user: user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"],
	"object" => note.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def article_activity_factory do
	article = insert(:article)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => article.data["actor"],
	"to" => article.data["to"],
	"object" => article.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => article.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def announce_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Announce",
	"actor" => note_activity.actor,
	"object" => note_activity.data["id"],
	"to" => [user.follower_address, note_activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => note_activity.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: user.ap_id,
	recipients: data["to"]
	}
	end

	def like_activity_factory do
	note_activity = insert(:note_activity)
	user = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Like",
	"object" => note_activity.data["object"]["id"],
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data
	}
	end

	def follow_activity_factory do
	follower = insert(:user)
	followed = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data,
	actor: follower.ap_id
	}
	end

	def websub_subscription_factory do
	%Pleroma.Web.Websub.WebsubServerSubscription{
	topic: "http://example.org",
	callback: "http://example.org/callback",
	secret: "here's a secret",
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 100),
	state: "requested"
	}
	end

	def websub_client_subscription_factory do
	%Pleroma.Web.Websub.WebsubClientSubscription{
	topic: "http://example.org",
	secret: "here's a secret",
	valid_until: nil,
	state: "requested",
	subscribers: []
	}
	end

	def oauth_app_factory do
	%Pleroma.Web.OAuth.App{
	client_name: "Some client",
	redirect_uris: "https://example.com/callback",
	scopes: ["read", "write", "follow", "push"],
	website: "https://example.com",
	client_id: Ecto.UUID.generate(),
	client_secret: "aaa;/&bbb"
	}
	end

	def instance_factory do
	%Pleroma.Instances.Instance{
	host: "domain.com",
	unreachable_since: nil
	}
	end

	def oauth_token_factory do
	oauth_app = insert(:oauth_app)

	%Pleroma.Web.OAuth.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	refresh_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	user: build(:user),
	app_id: oauth_app.id,
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10)
	}
	end

	def oauth_authorization_factory do
	%Pleroma.Web.OAuth.Authorization{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	scopes: ["read", "write", "follow", "push"],
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user),
	app: build(:oauth_app)
	}
	end

	def push_subscription_factory do
	%Pleroma.Web.Push.Subscription{
	user: build(:user),
	token: build(:oauth_token),
	endpoint: "https://example.com/example/1234",
	key_auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	key_p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA=",
	data: %{}
	}
	end

	def notification_factory do
	%Pleroma.Notification{
	user: build(:user)
	}
	end

	def scheduled_activity_factory do
	%Pleroma.ScheduledActivity{
	user: build(:user),
	scheduled_at: NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(60), :millisecond),
	params: build(:note) \|> Map.from_struct() \|> Map.get(:data)
	}
	end

	def registration_factory do
	user = insert(:user)

	%Pleroma.Registration{
	user: user,
	provider: "twitter",
	uid: "171799000",
	info: %{
	"name" => "John Doe",
	"email" => "john@doe.com",
	"nickname" => "johndoe",
	"description" => "My bio"
	}
	}
	end

	def config_factory do
	%Pleroma.Web.AdminAPI.Config{
	key: sequence(:key, &"some_key_#{&1}"),
	+ group: "pleroma",
	value:
	sequence(
	:value,
	fn key ->
	:erlang.term_to_binary(%{another_key: "#{key}somevalue", another: "#{key}somevalue"})
	end
	)
	}
	end
	end
	diff --git a/test/tasks/config_test.exs b/test/tasks/config_test.exs
	index d448b0444..9c9a31bf4 100644
	--- a/test/tasks/config_test.exs
	+++ b/test/tasks/config_test.exs
	@@ -1,54 +1,63 @@
	defmodule Mix.Tasks.Pleroma.ConfigTest do
	use Pleroma.DataCase
	alias Pleroma.Repo
	alias Pleroma.Web.AdminAPI.Config

	setup_all do
	Mix.shell(Mix.Shell.Process)
	temp_file = "config/temp.exported_from_db.secret.exs"

	dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])

	Pleroma.Config.put([:instance, :dynamic_configuration], true)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	Application.delete_env(:pleroma, :first_setting)
	Application.delete_env(:pleroma, :second_setting)
	Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
	:ok = File.rm(temp_file)
	end)

	{:ok, temp_file: temp_file}
	end

	test "settings are migrated to db" do
	assert Repo.all(Config) == []

	Application.put_env(:pleroma, :first_setting, key: "value", key2: [Pleroma.Repo])
	Application.put_env(:pleroma, :second_setting, key: "value2", key2: [Pleroma.Activity])

	Mix.Tasks.Pleroma.Config.run(["migrate_to_db"])

	- first_db = Config.get_by_key("first_setting")
	- second_db = Config.get_by_key("second_setting")
	- refute Config.get_by_key("Pleroma.Repo")
	+ first_db = Config.get_by_params(%{group: "pleroma", key: "first_setting"})
	+ second_db = Config.get_by_params(%{group: "pleroma", key: "second_setting"})
	+ refute Config.get_by_params(%{group: "pleroma", key: "Pleroma.Repo"})

	assert Config.from_binary(first_db.value) == [key: "value", key2: [Pleroma.Repo]]
	assert Config.from_binary(second_db.value) == [key: "value2", key2: [Pleroma.Activity]]
	end

	test "settings are migrated to file and deleted from db", %{temp_file: temp_file} do
	- Config.create(%{key: "setting_first", value: [key: "value", key2: [Pleroma.Activity]]})
	- Config.create(%{key: "setting_second", value: [key: "valu2", key2: [Pleroma.Repo]]})
	+ Config.create(%{
	+ group: "pleroma",
	+ key: "setting_first",
	+ value: [key: "value", key2: [Pleroma.Activity]]
	+ })
	+
	+ Config.create(%{
	+ group: "pleroma",
	+ key: "setting_second",
	+ value: [key: "valu2", key2: [Pleroma.Repo]]
	+ })

	Mix.Tasks.Pleroma.Config.run(["migrate_from_db", "temp"])

	assert Repo.all(Config) == []
	assert File.exists?(temp_file)
	{:ok, file} = File.read(temp_file)

	assert file =~ "config :pleroma, setting_first:"
	assert file =~ "config :pleroma, setting_second:"
	end
	end
	diff --git a/test/web/activity_pub/mrf/anti_link_spam_policy_test.exs b/test/web/activity_pub/mrf/anti_link_spam_policy_test.exs
	index 284c13336..03dc299ec 100644
	--- a/test/web/activity_pub/mrf/anti_link_spam_policy_test.exs
	+++ b/test/web/activity_pub/mrf/anti_link_spam_policy_test.exs
	@@ -1,140 +1,145 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.AntiLinkSpamPolicyTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	+ import ExUnit.CaptureLog

	alias Pleroma.Web.ActivityPub.MRF.AntiLinkSpamPolicy

	@linkless_message %{
	"type" => "Create",
	"object" => %{
	"content" => "hi world!"
	}
	}

	@linkful_message %{
	"type" => "Create",
	"object" => %{
	"content" => "<a href='https://example.com'>hi world!</a>"
	}
	}

	@response_message %{
	"type" => "Create",
	"object" => %{
	"name" => "yes",
	"type" => "Answer"
	}
	}

	describe "with new user" do
	test "it allows posts without links" do
	user = insert(:user)

	assert user.info.note_count == 0

	message =
	@linkless_message
	\|> Map.put("actor", user.ap_id)

	{:ok, _message} = AntiLinkSpamPolicy.filter(message)
	end

	test "it disallows posts with links" do
	user = insert(:user)

	assert user.info.note_count == 0

	message =
	@linkful_message
	\|> Map.put("actor", user.ap_id)

	{:reject, _} = AntiLinkSpamPolicy.filter(message)
	end
	end

	describe "with old user" do
	test "it allows posts without links" do
	user = insert(:user, info: %{note_count: 1})

	assert user.info.note_count == 1

	message =
	@linkless_message
	\|> Map.put("actor", user.ap_id)

	{:ok, _message} = AntiLinkSpamPolicy.filter(message)
	end

	test "it allows posts with links" do
	user = insert(:user, info: %{note_count: 1})

	assert user.info.note_count == 1

	message =
	@linkful_message
	\|> Map.put("actor", user.ap_id)

	{:ok, _message} = AntiLinkSpamPolicy.filter(message)
	end
	end

	describe "with followed new user" do
	test "it allows posts without links" do
	user = insert(:user, info: %{follower_count: 1})

	assert user.info.follower_count == 1

	message =
	@linkless_message
	\|> Map.put("actor", user.ap_id)

	{:ok, _message} = AntiLinkSpamPolicy.filter(message)
	end

	test "it allows posts with links" do
	user = insert(:user, info: %{follower_count: 1})

	assert user.info.follower_count == 1

	message =
	@linkful_message
	\|> Map.put("actor", user.ap_id)

	{:ok, _message} = AntiLinkSpamPolicy.filter(message)
	end
	end

	describe "with unknown actors" do
	test "it rejects posts without links" do
	message =
	@linkless_message
	\|> Map.put("actor", "http://invalid.actor")

	- {:reject, _} = AntiLinkSpamPolicy.filter(message)
	+ assert capture_log(fn ->
	+ {:reject, _} = AntiLinkSpamPolicy.filter(message)
	+ end) =~ "[error] Could not decode user at fetch http://invalid.actor"
	end

	test "it rejects posts with links" do
	message =
	@linkful_message
	\|> Map.put("actor", "http://invalid.actor")

	- {:reject, _} = AntiLinkSpamPolicy.filter(message)
	+ assert capture_log(fn ->
	+ {:reject, _} = AntiLinkSpamPolicy.filter(message)
	+ end) =~ "[error] Could not decode user at fetch http://invalid.actor"
	end
	end

	describe "with contentless-objects" do
	test "it does not reject them or error out" do
	user = insert(:user, info: %{note_count: 1})

	message =
	@response_message
	\|> Map.put("actor", user.ap_id)

	{:ok, _message} = AntiLinkSpamPolicy.filter(message)
	end
	end
	end
	diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/admin_api_controller_test.exs
	index 2a5912645..4278ac59d 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,1467 +1,1636 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory

	describe "/api/pleroma/admin/users" do
	test "Delete" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")

	assert json_response(conn, 200) == user.nickname
	end

	test "Create" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	})

	assert json_response(conn, 200) == "lain"
	end
	end

	describe "/api/pleroma/admin/users/:nickname" do
	test "Show", %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users/#{user.nickname}")

	expected = %{
	"deactivated" => false,
	"id" => to_string(user.id),
	"local" => true,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"tags" => []
	}

	assert expected == json_response(conn, 200)
	end

	test "when the user doesn't exist", %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	user = build(:user)

	conn =
	conn
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users/#{user.nickname}")

	assert "Not found" == json_response(conn, 404)
	end
	end

	describe "/api/pleroma/admin/users/follow" do
	test "allows to force-follow another user" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)
	follower = insert(:user)

	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/follow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, user)
	end
	end

	describe "/api/pleroma/admin/users/unfollow" do
	test "allows to force-unfollow another user" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/unfollow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	end
	end

	describe "PUT /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=foo&tags[]=bar"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it appends specified tags to users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
	assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "DELETE /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=x&tags[]=z"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it removes specified tags from users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == []
	assert User.get_cached_by_id(user2.id).tags == ["y"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "/api/pleroma/admin/users/:nickname/permission_group" do
	test "GET is giving user_info" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")

	assert json_response(conn, 200) == %{
	"is_admin" => true,
	"is_moderator" => false
	}
	end

	test "/:right POST, can add to a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => true
	}
	end

	test "/:right DELETE, can remove from a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => false
	}
	end
	end

	describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	conn
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")

	%{conn: conn}
	end

	test "deactivates the user", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})

	user = User.get_cached_by_id(user.id)
	assert user.info.deactivated == true
	assert json_response(conn, :no_content)
	end

	test "activates the user", %{conn: conn} do
	user = insert(:user, info: %{deactivated: true})

	conn =
	conn
	\|> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})

	user = User.get_cached_by_id(user.id)
	assert user.info.deactivated == false
	assert json_response(conn, :no_content)
	end

	test "returns 403 when requested by a non-admin", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/email_invite, with valid config" do
	setup do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	[user: insert(:user, info: %{is_admin: true})]
	end

	test "sends invitation and returns 204", %{conn: conn, user: user} do
	recipient_email = "foo@bar.com"
	recipient_name = "J. D."

	conn =
	conn
	\|> assign(:user, user)
	\|> post(
	"/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
	)

	assert json_response(conn, :no_content)

	token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
	assert token_record
	refute token_record.used

	notify_email = Pleroma.Config.get([:instance, :notify_email])
	instance_name = Pleroma.Config.get([:instance, :name])

	email =
	Pleroma.Emails.UserEmail.user_invitation_email(
	user,
	token_record,
	recipient_email,
	recipient_name
	)

	Swoosh.TestAssertions.assert_email_sent(
	from: {instance_name, notify_email},
	to: {recipient_name, recipient_email},
	html_body: email.html_body
	)
	end

	test "it returns 403 if requested by a non-admin", %{conn: conn} do
	non_admin_user = insert(:user)

	conn =
	conn
	\|> assign(:user, non_admin_user)
	\|> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
	setup do
	[user: insert(:user, info: %{is_admin: true})]
	end

	test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], false)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end

	test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], true)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end
	end

	test "/api/pleroma/admin/users/invite_token" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/invite_token")

	assert conn.status == 200
	end

	test "/api/pleroma/admin/users/:nickname/password_reset" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")

	assert conn.status == 200
	end

	describe "GET /api/pleroma/admin/users" do
	setup do
	admin = insert(:user, info: %{is_admin: true})

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

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

	test "renders users array for the first page", %{conn: conn, admin: admin} do
	user = insert(:user, local: false, tags: ["foo", "bar"])
	conn = get(conn, "/api/pleroma/admin/users?page=1")

	users =
	[
	%{
	"deactivated" => admin.info.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => []
	},
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => false,
	"tags" => ["foo", "bar"]
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "renders empty array for the second page", %{conn: conn} do
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?page=2")

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => []
	}
	end

	test "regular search", %{conn: conn} do
	user = insert(:user, nickname: "bob")

	conn = get(conn, "/api/pleroma/admin/users?query=bo")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "search by domain", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=domain.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "search by full nickname", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "search by display name", %{conn: conn} do
	user = insert(:user, name: "Display name")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?name=display")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "search by email", %{conn: conn} do
	user = insert(:user, email: "email@example.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "regular search with page size", %{conn: conn} do
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")

	assert json_response(conn1, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}

	conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")

	assert json_response(conn2, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [
	%{
	"deactivated" => user2.info.deactivated,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "only local users" do
	admin = insert(:user, info: %{is_admin: true}, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?query=bo&filters=local")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "only local users with no query", %{admin: old_admin} do
	admin = insert(:user, info: %{is_admin: true}, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?filters=local")

	users =
	[
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	},
	%{
	"deactivated" => admin.info.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => []
	},
	%{
	"deactivated" => false,
	"id" => old_admin.id,
	"local" => true,
	"nickname" => old_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"tags" => []
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only admins", %{conn: conn, admin: admin} do
	second_admin = insert(:user, info: %{is_admin: true})
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")

	users =
	[
	%{
	"deactivated" => false,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => admin.local,
	"tags" => []
	},
	%{
	"deactivated" => false,
	"id" => second_admin.id,
	"nickname" => second_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => second_admin.local,
	"tags" => []
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "load only moderators", %{conn: conn} do
	moderator = insert(:user, info: %{is_moderator: true})
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => false,
	"id" => moderator.id,
	"nickname" => moderator.nickname,
	"roles" => %{"admin" => false, "moderator" => true},
	"local" => moderator.local,
	"tags" => []
	}
	]
	}
	end

	test "load users with tags list", %{conn: conn} do
	user1 = insert(:user, tags: ["first"])
	user2 = insert(:user, tags: ["second"])
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")

	users =
	[
	%{
	"deactivated" => false,
	"id" => user1.id,
	"nickname" => user1.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user1.local,
	"tags" => ["first"]
	},
	%{
	"deactivated" => false,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user2.local,
	"tags" => ["second"]
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	end

	test "it works with multiple filters" do
	admin = insert(:user, nickname: "john", info: %{is_admin: true})
	user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})

	insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
	insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?filters=deactivated,external")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user.local,
	"tags" => []
	}
	]
	}
	end
	end

	test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")

	assert json_response(conn, 200) ==
	%{
	"deactivated" => !user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	end

	describe "GET /api/pleroma/admin/users/invite_token" do
	setup do
	admin = insert(:user, info: %{is_admin: true})

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

	{:ok, conn: conn}
	end

	test "without options", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/users/invite_token")

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	refute invite.expires_at
	refute invite.max_use
	assert invite.invite_type == "one_time"
	end

	test "with expires_at", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/invite_token", %{
	"invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)

	refute invite.used
	assert invite.expires_at == Date.utc_today()
	refute invite.max_use
	assert invite.invite_type == "date_limited"
	end

	test "with max_use", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/invite_token", %{
	"invite" => %{"max_use" => 150}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	refute invite.expires_at
	assert invite.max_use == 150
	assert invite.invite_type == "reusable"
	end

	test "with max use and expires_at", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/invite_token", %{
	"invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	assert invite.expires_at == Date.utc_today()
	assert invite.max_use == 150
	assert invite.invite_type == "reusable_date_limited"
	end
	end

	describe "GET /api/pleroma/admin/users/invites" do
	setup do
	admin = insert(:user, info: %{is_admin: true})

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

	{:ok, conn: conn}
	end

	test "no invites", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/users/invites")

	assert json_response(conn, 200) == %{"invites" => []}
	end

	test "with invite", %{conn: conn} do
	{:ok, invite} = UserInviteToken.create_invite()

	conn = get(conn, "/api/pleroma/admin/users/invites")

	assert json_response(conn, 200) == %{
	"invites" => [
	%{
	"expires_at" => nil,
	"id" => invite.id,
	"invite_type" => "one_time",
	"max_use" => nil,
	"token" => invite.token,
	"used" => false,
	"uses" => 0
	}
	]
	}
	end
	end

	describe "POST /api/pleroma/admin/users/revoke_invite" do
	test "with token" do
	admin = insert(:user, info: %{is_admin: true})
	{:ok, invite} = UserInviteToken.create_invite()

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})

	assert json_response(conn, 200) == %{
	"expires_at" => nil,
	"id" => invite.id,
	"invite_type" => "one_time",
	"max_use" => nil,
	"token" => invite.token,
	"used" => true,
	"uses" => 0
	}
	end
	end

	describe "GET /api/pleroma/admin/reports/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	%{conn: assign(conn, :user, admin)}
	end

	test "returns report by its id", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports/#{report_id}")
	\|> json_response(:ok)

	assert response["id"] == report_id
	end

	test "returns 404 when report id is invalid", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/reports/test")

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "PUT /api/pleroma/admin/reports/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	%{conn: assign(conn, :user, admin), id: report_id}
	end

	test "mark report as resolved", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
	\|> json_response(:ok)

	assert response["state"] == "resolved"
	end

	test "closes report", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
	\|> json_response(:ok)

	assert response["state"] == "closed"
	end

	test "returns 400 when state is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})

	assert json_response(conn, :bad_request) == "Unsupported state"
	end

	test "returns 404 when report is not exist", %{conn: conn} do
	conn =
	conn
	\|> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "GET /api/pleroma/admin/reports" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	%{conn: assign(conn, :user, admin)}
	end

	test "returns empty response when no reports created", %{conn: conn} do
	response =
	conn
	\|> get("/api/pleroma/admin/reports")
	\|> json_response(:ok)

	assert Enum.empty?(response["reports"])
	end

	test "returns reports", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports")
	\|> json_response(:ok)

	[report] = response["reports"]

	assert length(response["reports"]) == 1
	assert report["id"] == report_id
	end

	test "returns reports with specified state", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, %{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I don't like this user"
	})

	CommonAPI.update_report_state(second_report_id, "closed")

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "open"
	})
	\|> json_response(:ok)

	[open_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert open_report["id"] == first_report_id

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "closed"
	})
	\|> json_response(:ok)

	[closed_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert closed_report["id"] == second_report_id

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "resolved"
	})
	\|> json_response(:ok)

	assert Enum.empty?(response["reports"])
	end

	test "returns 403 when requested by a non-admin" do
	user = insert(:user)

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

	assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
	end

	test "returns 403 when requested by anonymous" do
	conn =
	build_conn()
	\|> get("/api/pleroma/admin/reports")

	assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
	end
	end

	describe "POST /api/pleroma/admin/reports/:id/respond" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	%{conn: assign(conn, :user, admin)}
	end

	test "returns created dm", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
	"status" => "I will check it out"
	})
	\|> json_response(:ok)

	recipients = Enum.map(response["mentions"], & &1["username"])

	assert conn.assigns[:user].nickname in recipients
	assert reporter.nickname in recipients
	assert response["content"] == "I will check it out"
	assert response["visibility"] == "direct"
	end

	test "returns 400 when status is missing", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/reports/test/respond")

	assert json_response(conn, :bad_request) == "Invalid parameters"
	end

	test "returns 404 when report id is invalid", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/reports/test/respond", %{
	"status" => "foo"
	})

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "PUT /api/pleroma/admin/statuses/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	activity = insert(:note_activity)

	%{conn: assign(conn, :user, admin), id: activity.id}
	end

	test "toggle sensitive flag", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
	\|> json_response(:ok)

	assert response["sensitive"]

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
	\|> json_response(:ok)

	refute response["sensitive"]
	end

	test "change visibility flag", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
	\|> json_response(:ok)

	assert response["visibility"] == "public"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
	\|> json_response(:ok)

	assert response["visibility"] == "private"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
	\|> json_response(:ok)

	assert response["visibility"] == "unlisted"
	end

	test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})

	assert json_response(conn, :bad_request) == "Unsupported visibility"
	end
	end

	describe "DELETE /api/pleroma/admin/statuses/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	activity = insert(:note_activity)

	%{conn: assign(conn, :user, admin), id: activity.id}
	end

	test "deletes status", %{conn: conn, id: id} do
	conn
	\|> delete("/api/pleroma/admin/statuses/#{id}")
	\|> json_response(:ok)

	refute Activity.get_by_id(id)
	end

	test "returns error when status is not exist", %{conn: conn} do
	conn =
	conn
	\|> delete("/api/pleroma/admin/statuses/test")

	assert json_response(conn, :bad_request) == "Could not delete"
	end
	end

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

	%{conn: assign(conn, :user, admin)}
	end

	test "without any settings in db", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config")

	assert json_response(conn, 200) == %{"configs" => []}
	end

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

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

	%{
	"configs" => [
	%{
	"key" => key1,
	"value" => _
	},
	%{
	"key" => key2,
	"value" => _
	}
	]
	} = json_response(conn, 200)

	assert key1 == config1.key
	assert key2 == config2.key
	end
	end

	describe "POST /api/pleroma/admin/config" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	temp_file = "config/test.exported_from_db.secret.exs"

	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)
	:ok = File.rm(temp_file)
	end)

	dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])

	Pleroma.Config.put([:instance, :dynamic_configuration], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
	end)

	%{conn: assign(conn, :user, admin)}
	end

	test "create new config setting in db", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	- %{key: "key1", value: "value1"},
	+ %{group: "pleroma", key: "key1", value: "value1"},
	%{
	+ 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(conn, 200) == %{
	"configs" => [
	%{
	+ "group" => "pleroma",
	"key" => "key1",
	"value" => "value1"
	},
	%{
	+ "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" => [%{"endpoint" => "https://example.com"}, %{"nested_5" => "upload"}]
	+ },
	+ %{
	+ "group" => "idna",
	+ "key" => "key5",
	+ "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	}

	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 "update config setting & delete", %{conn: conn} do
	config1 = insert(:config, key: "keyaa1")
	config2 = insert(:config, key: "keyaa2")

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	- %{key: config1.key, value: "another_value"},
	- %{key: config2.key, delete: "true"}
	+ %{group: config1.group, key: config1.key, value: "another_value"},
	+ %{group: config2.group, key: config2.key, delete: "true"}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	+ "group" => "pleroma",
	"key" => config1.key,
	"value" => "another_value"
	}
	]
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	refute Application.get_env(:pleroma, :keyaa2)
	end
	+
	+ test "common config example", %{conn: conn} do
	+ conn =
	+ post(conn, "/api/pleroma/admin/config", %{
	+ configs: [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "Pleroma.Captcha.NotReal",
	+ "value" => %{
	+ "enabled" => ":false",
	+ "method" => "Pleroma.Captcha.Kocaptcha",
	+ "seconds_valid" => "i:60"
	+ }
	+ }
	+ ]
	+ })
	+
	+ assert json_response(conn, 200) == %{
	+ "configs" => [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "Pleroma.Captcha.NotReal",
	+ "value" => [
	+ %{"enabled" => false},
	+ %{"method" => "Pleroma.Captcha.Kocaptcha"},
	+ %{"seconds_valid" => 60}
	+ ]
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "tuples with more than two values", %{conn: conn} do
	+ conn =
	+ post(conn, "/api/pleroma/admin/config", %{
	+ configs: [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "Pleroma.Web.Endpoint.NotReal",
	+ "value" => [
	+ %{
	+ "http" => %{
	+ "dispatch" => [
	+ %{
	+ "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(conn, 200) == %{
	+ "configs" => [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "Pleroma.Web.Endpoint.NotReal",
	+ "value" => [
	+ %{
	+ "http" => %{
	+ "dispatch" => %{
	+ "_" => [
	+ %{
	+ "tuple" => [
	+ "/api/v1/streaming",
	+ "Pleroma.Web.MastodonAPI.WebsocketHandler",
	+ []
	+ ]
	+ },
	+ %{
	+ "tuple" => [
	+ "/websocket",
	+ "Phoenix.Endpoint.CowboyWebSocket",
	+ %{
	+ "Elixir.Phoenix.Transports.WebSocket" => %{
	+ "tuple" => [
	+ "Pleroma.Web.Endpoint",
	+ "Pleroma.Web.UserSocket",
	+ []
	+ ]
	+ }
	+ }
	+ ]
	+ },
	+ %{
	+ "tuple" => [
	+ "_",
	+ "Phoenix.Endpoint.Cowboy2Handler",
	+ %{"Elixir.Pleroma.Web.Endpoint" => []}
	+ ]
	+ }
	+ ]
	+ }
	+ }
	+ }
	+ ]
	+ }
	+ ]
	+ }
	+ end
	end
	end
	+
	+# Needed for testing
	+defmodule Pleroma.Web.Endpoint.NotReal do
	+end
	+
	+defmodule Pleroma.Captcha.NotReal do
	+end
	diff --git a/test/web/admin_api/config_test.exs b/test/web/admin_api/config_test.exs
	index a2fedca40..10cb3b68a 100644
	--- a/test/web/admin_api/config_test.exs
	+++ b/test/web/admin_api/config_test.exs
	@@ -1,183 +1,258 @@
	defmodule Pleroma.Web.AdminAPI.ConfigTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.Web.AdminAPI.Config

	test "get_by_key/1" do
	config = insert(:config)
	insert(:config)

	- assert config == Config.get_by_key(config.key)
	+ assert config == Config.get_by_params(%{group: config.group, key: config.key})
	end

	test "create/1" do
	- {:ok, config} = Config.create(%{key: "some_key", value: "some_value"})
	- assert config == Config.get_by_key("some_key")
	+ {:ok, config} = Config.create(%{group: "pleroma", key: "some_key", value: "some_value"})
	+ assert config == Config.get_by_params(%{group: "pleroma", key: "some_key"})
	end

	test "update/1" do
	config = insert(:config)
	{:ok, updated} = Config.update(config, %{value: "some_value"})
	- loaded = Config.get_by_key(config.key)
	+ loaded = Config.get_by_params(%{group: config.group, key: config.key})
	assert loaded == updated
	end

	test "update_or_create/1" do
	config = insert(:config)
	key2 = "another_key"

	params = [
	- %{key: key2, value: "another_value"},
	- %{key: config.key, value: "new_value"}
	+ %{group: "pleroma", key: key2, value: "another_value"},
	+ %{group: config.group, key: config.key, value: "new_value"}
	]

	assert Repo.all(Config) \|> length() == 1

	Enum.each(params, &Config.update_or_create(&1))

	assert Repo.all(Config) \|> length() == 2

	- config1 = Config.get_by_key(config.key)
	- config2 = Config.get_by_key(key2)
	+ config1 = Config.get_by_params(%{group: config.group, key: config.key})
	+ config2 = Config.get_by_params(%{group: "pleroma", key: key2})

	assert config1.value == Config.transform("new_value")
	assert config2.value == Config.transform("another_value")
	end

	test "delete/1" do
	config = insert(:config)
	- {:ok, _} = Config.delete(config.key)
	- refute Config.get_by_key(config.key)
	+ {:ok, _} = Config.delete(%{key: config.key, group: config.group})
	+ refute Config.get_by_params(%{key: config.key, group: config.group})
	end

	describe "transform/1" do
	test "string" do
	binary = Config.transform("value as string")
	assert binary == :erlang.term_to_binary("value as string")
	assert Config.from_binary(binary) == "value as string"
	end

	test "list of modules" do
	binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
	assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
	assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
	end

	test "list of strings" do
	binary = Config.transform(["string1", "string2"])
	assert binary == :erlang.term_to_binary(["string1", "string2"])
	assert Config.from_binary(binary) == ["string1", "string2"]
	end

	test "map" do
	binary =
	Config.transform(%{
	"types" => "Pleroma.PostgresTypes",
	"telemetry_event" => ["Pleroma.Repo.Instrumenter"],
	"migration_lock" => ""
	})

	assert binary ==
	:erlang.term_to_binary(
	telemetry_event: [Pleroma.Repo.Instrumenter],
	types: Pleroma.PostgresTypes
	)

	assert Config.from_binary(binary) == [
	telemetry_event: [Pleroma.Repo.Instrumenter],
	types: Pleroma.PostgresTypes
	]
	end

	test "complex map with nested integers, lists and atoms" do
	binary =
	Config.transform(%{
	"uploader" => "Pleroma.Uploaders.Local",
	"filters" => ["Pleroma.Upload.Filter.Dedupe"],
	"link_name" => ":true",
	"proxy_remote" => ":false",
	"proxy_opts" => %{
	"redirect_on_failure" => ":false",
	"max_body_length" => "i:1048576",
	"http" => %{
	"follow_redirect" => ":true",
	"pool" => ":upload"
	}
	}
	})

	assert binary ==
	:erlang.term_to_binary(
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_opts: [
	http: [
	follow_redirect: true,
	pool: :upload
	],
	max_body_length: 1_048_576,
	redirect_on_failure: false
	],
	proxy_remote: false,
	uploader: Pleroma.Uploaders.Local
	)

	assert Config.from_binary(binary) ==
	[
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_opts: [
	http: [
	follow_redirect: true,
	pool: :upload
	],
	max_body_length: 1_048_576,
	redirect_on_failure: false
	],
	proxy_remote: false,
	uploader: Pleroma.Uploaders.Local
	]
	end

	test "keyword" do
	binary =
	Config.transform(%{
	"level" => ":warn",
	"meta" => [":all"],
	"webhook_url" => "https://hooks.slack.com/services/YOUR-KEY-HERE"
	})

	assert binary ==
	:erlang.term_to_binary(
	level: :warn,
	meta: [:all],
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	)

	assert Config.from_binary(binary) == [
	level: :warn,
	meta: [:all],
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	]
	end

	test "complex map with sigil" do
	binary =
	Config.transform(%{
	federated_timeline_removal: [],
	reject: [~r/comp[lL][aA][iI][nN]er/],
	replace: []
	})

	assert binary ==
	:erlang.term_to_binary(
	federated_timeline_removal: [],
	reject: [~r/comp[lL][aA][iI][nN]er/],
	replace: []
	)

	assert Config.from_binary(binary) ==
	[federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
	end
	+
	+ test "complex map with tuples with more than 2 values" do
	+ binary =
	+ Config.transform(%{
	+ "http" => %{
	+ "dispatch" => [
	+ %{
	+ "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 binary ==
	+ :erlang.term_to_binary(
	+ http: [
	+ dispatch: [
	+ _: [
	+ {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	+ {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	+ {Phoenix.Transports.WebSocket,
	+ {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	+ {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	+ ]
	+ ]
	+ ]
	+ )
	+
	+ assert Config.from_binary(binary) == [
	+ http: [
	+ dispatch: [
	+ {:_,
	+ [
	+ {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	+ {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	+ {Phoenix.Transports.WebSocket,
	+ {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	+ {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	+ ]}
	+ ]
	+ ]
	+ ]
	+ end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 14, 7:27 AM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 166736
Default Alt Text: (117 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions