No OneTemporary
Actions

Authored By

Unknown

Size

135 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index f27446f36..da2aee883 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,202 +1,207 @@
	# Changelog
	All notable changes to this project will be documented in this file.

	The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

	## [Unreleased]
	### Changed
	- Breaking: Configuration: A setting to explicitly disable the mailer was added, defaulting to true, if you are using a mailer add `config :pleroma, Pleroma.Emails.Mailer, enabled: true` to your config
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- NodeInfo: Return `skipThreadContainment` in `metadata` for the `skip_thread_containment` option

	### Fixed
	- Not being able to pin unlisted posts
	- Metadata rendering errors resulting in the entire page being inaccessible
	- Mastodon API: Handling of search timeouts (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API: Embedded relationships not being properly rendered in the Account entity of Status entity

	### Added
	- MRF: Support for priming the mediaproxy cache (`Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`)
	Configuration: `federation_incoming_replies_max_depth` option
	- Mastodon API: Support for the [`tagged` filter](https://github.com/tootsuite/mastodon/pull/9755) in [`GET /api/v1/accounts/:id/statuses`](https://docs.joinmastodon.org/api/rest/accounts/#get-api-v1-accounts-id-statuses)
	- Mastodon API, streaming: Add support for passing the token in the `Sec-WebSocket-Protocol` header
	- Mastodon API, extension: Ability to reset avatar, profile banner, and background
	- Admin API: Return users' tags when querying reports
	- Admin API: Return avatar and display name when querying users
	- Admin API: Allow querying user by ID
	+- Admin API: Added support for `tuples`.
	- Added synchronization of following/followers counters for external users
	- Configuration: `enabled` option for `Pleroma.Emails.Mailer`, defaulting to `false`.
	- Mastodon API: Add support for categories for custom emojis by reusing the group feature. <https://github.com/tootsuite/mastodon/pull/11196>

	+### Changed
	+- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	+- Admin API: changed json structure for saving config settings.
	+
	## [1.0.0] - 2019-06-29
	### Security
	- Mastodon API: Fix display names not being sanitized
	- Rich media: Do not crawl private IP ranges

	### Added
	- Add a generic settings store for frontends / clients to use.
	- Explicit addressing option for posting.
	- Optional SSH access mode. (Needs `erlang-ssh` package on some distributions).
	- [MongooseIM](https://github.com/esl/MongooseIM) http authentication support.
	- LDAP authentication
	- External OAuth provider authentication
	- Support for building a release using [`mix release`](https://hexdocs.pm/mix/master/Mix.Tasks.Release.html)
	- A [job queue](https://git.pleroma.social/pleroma/pleroma_job_queue) for federation, emails, web push, etc.
	- [Prometheus](https://prometheus.io/) metrics
	- Support for Mastodon's remote interaction
	- Mix Tasks: `mix pleroma.database bump_all_conversations`
	- Mix Tasks: `mix pleroma.database remove_embedded_objects`
	- Mix Tasks: `mix pleroma.database update_users_following_followers_counts`
	- Mix Tasks: `mix pleroma.user toggle_confirmed`
	- Mix Tasks: `mix pleroma.config migrate_to_db`
	- Mix Tasks: `mix pleroma.config migrate_from_db`
	- Federation: Support for `Question` and `Answer` objects
	- Federation: Support for reports
	- Configuration: `poll_limits` option
	- Configuration: `pack_extensions` option
	- Configuration: `safe_dm_mentions` option
	- Configuration: `link_name` option
	- Configuration: `fetch_initial_posts` option
	- Configuration: `notify_email` option
	- Configuration: Media proxy `whitelist` option
	- Configuration: `report_uri` option
	- Configuration: `limit_to_local_content` option
	- Pleroma API: User subscriptions
	- Pleroma API: Healthcheck endpoint
	- Pleroma API: `/api/v1/pleroma/mascot` per-user frontend mascot configuration endpoints
	- Admin API: Endpoints for listing/revoking invite tokens
	- Admin API: Endpoints for making users follow/unfollow each other
	- Admin API: added filters (role, tags, email, name) for users endpoint
	- Admin API: Endpoints for managing reports
	- Admin API: Endpoints for deleting and changing the scope of individual reported statuses
	- Admin API: Endpoints to view and change config settings.
	- AdminFE: initial release with basic user management accessible at /pleroma/admin/
	- Mastodon API: Add chat token to `verify_credentials` response
	- Mastodon API: Add background image setting to `update_credentials`
	- Mastodon API: [Scheduled statuses](https://docs.joinmastodon.org/api/rest/scheduled-statuses/)
	- Mastodon API: `/api/v1/notifications/destroy_multiple` (glitch-soc extension)
	- Mastodon API: `/api/v1/pleroma/accounts/:id/favourites` (API extension)
	- Mastodon API: [Reports](https://docs.joinmastodon.org/api/rest/reports/)
	- Mastodon API: `POST /api/v1/accounts` (account creation API)
	- Mastodon API: [Polls](https://docs.joinmastodon.org/api/rest/polls/)
	- ActivityPub C2S: OAuth endpoints
	- Metadata: RelMe provider
	- OAuth: added support for refresh tokens
	- Emoji packs and emoji pack manager
	- Object pruning (`mix pleroma.database prune_objects`)
	- OAuth: added job to clean expired access tokens
	- MRF: Support for rejecting reports from specific instances (`mrf_simple`)
	- MRF: Support for stripping avatars and banner images from specific instances (`mrf_simple`)
	- MRF: Support for running subchains.
	- Configuration: `skip_thread_containment` option
	- Configuration: `rate_limit` option. See `Pleroma.Plugs.RateLimiter` documentation for details.
	- MRF: Support for filtering out likely spam messages by rejecting posts from new users that contain links.
	- Configuration: `ignore_hosts` option
	- Configuration: `ignore_tld` option
	- Configuration: default syslog tag "Pleroma" is now lowercased to "pleroma"

	### Changed
	- Breaking: bind to 127.0.0.1 instead of 0.0.0.0 by default
	- Breaking: Configuration: move from Pleroma.Mailer to Pleroma.Emails.Mailer
	- Thread containment / test for complete visibility will be skipped by default.
	- Enforcement of OAuth scopes
	- Add multiple use/time expiring invite token
	- Restyled OAuth pages to fit with Pleroma's default theme
	- Link/mention/hashtag detection is now handled by [auto_linker](https://git.pleroma.social/pleroma/auto_linker)
	- NodeInfo: Return `safe_dm_mentions` feature flag
	- Federation: Expand the audience of delete activities to all recipients of the deleted object
	- Federation: Removed `inReplyToStatusId` from objects
	- Configuration: Dedupe enabled by default
	- Configuration: Default log level in `prod` environment is now set to `warn`
	- Configuration: Added `extra_cookie_attrs` for setting non-standard cookie attributes. Defaults to ["SameSite=Lax"] so that remote follows work.
	- Timelines: Messages involving people you have blocked will be excluded from the timeline in all cases instead of just repeats.
	- Admin API: Move the user related API to `api/pleroma/admin/users`
	- Pleroma API: Support for emoji tags in `/api/pleroma/emoji` resulting in a breaking API change
	- Mastodon API: Support for `exclude_types`, `limit` and `min_id` in `/api/v1/notifications`
	- Mastodon API: Add `languages` and `registrations` to `/api/v1/instance`
	- Mastodon API: Provide plaintext versions of cw/content in the Status entity
	- Mastodon API: Add `pleroma.conversation_id`, `pleroma.in_reply_to_account_acct` fields to the Status entity
	- Mastodon API: Add `pleroma.tags`, `pleroma.relationship{}`, `pleroma.is_moderator`, `pleroma.is_admin`, `pleroma.confirmation_pending`, `pleroma.hide_followers`, `pleroma.hide_follows`, `pleroma.hide_favorites` fields to the User entity
	- Mastodon API: Add `pleroma.show_role`, `pleroma.no_rich_text` fields to the Source subentity
	- Mastodon API: Add support for updating `no_rich_text`, `hide_followers`, `hide_follows`, `hide_favorites`, `show_role` in `PATCH /api/v1/update_credentials`
	- Mastodon API: Add `pleroma.is_seen` to the Notification entity
	- Mastodon API: Add `pleroma.local` to the Status entity
	- Mastodon API: Add `preview` parameter to `POST /api/v1/statuses`
	- Mastodon API: Add `with_muted` parameter to timeline endpoints
	- Mastodon API: Actual reblog hiding instead of a dummy
	- Mastodon API: Remove attachment limit in the Status entity
	- Mastodon API: Added support max_id & since_id for bookmark timeline endpoints.
	- Deps: Updated Cowboy to 2.6
	- Deps: Updated Ecto to 3.0.7
	- Don't ship finmoji by default, they can be installed as an emoji pack
	- Hide deactivated users and their statuses
	- Posts which are marked sensitive or tagged nsfw no longer have link previews.
	- HTTP connection timeout is now set to 10 seconds.
	- Respond with a 404 Not implemented JSON error message when requested API is not implemented
	- Rich Media: crawl only https URLs.

	### Fixed
	- Follow requests don't get 'stuck' anymore.
	- Added an FTS index on objects. Running `vacuum analyze` and setting a larger `work_mem` is recommended.
	- Followers counter not being updated when a follower is blocked
	- Deactivated users being able to request an access token
	- Limit on request body in rich media/relme parsers being ignored resulting in a possible memory leak
	- Proper Twitter Card generation instead of a dummy
	- Deletions failing for users with a large number of posts
	- NodeInfo: Include admins in `staffAccounts`
	- ActivityPub: Crashing when requesting empty local user's outbox
	- Federation: Handling of objects without `summary` property
	- Federation: Add a language tag to activities as required by ActivityStreams 2.0
	- Federation: Do not federate avatar/banner if set to default allowing other servers/clients to use their defaults
	- Federation: Cope with missing or explicitly nulled address lists
	- Federation: Explicitly ensure activities addressed to `as:Public` become addressed to the followers collection
	- Federation: Better cope with actors which do not declare a followers collection and use `as:Public` with these semantics
	- Federation: Follow requests from remote users who have been blocked will be automatically rejected if appropriate
	- MediaProxy: Parse name from content disposition headers even for non-whitelisted types
	- MediaProxy: S3 link encoding
	- Rich Media: Reject any data which cannot be explicitly encoded into JSON
	- Pleroma API: Importing follows from Mastodon 2.8+
	- Twitter API: Exposing default scope, `no_rich_text` of the user to anyone
	- Twitter API: Returning the `role` object in user entity despite `show_role = false`
	- Mastodon API: `/api/v1/favourites` serving only public activities
	- Mastodon API: Reblogs having `in_reply_to_id` - `null` even when they are replies
	- Mastodon API: Streaming API broadcasting wrong activity id
	- Mastodon API: 500 errors when requesting a card for a private conversation
	- Mastodon API: Handling of `reblogs` in `/api/v1/accounts/:id/follow`
	- Mastodon API: Correct `reblogged`, `favourited`, and `bookmarked` values in the reblog status JSON
	- Mastodon API: Exposing default scope of the user to anyone
	- Mastodon API: Make `irreversible` field default to `false` [`POST /api/v1/filters`]
	- Mastodon API: Replace missing non-nullable Card attributes with empty strings
	- User-Agent is now sent correctly for all HTTP requests.
	- MRF: Simple policy now properly delists imported or relayed statuses

	## Removed
	- Configuration: `config :pleroma, :fe` in favor of the more flexible `config :pleroma, :frontend_configurations`

	## [0.9.99999] - 2019-05-31
	### Security
	- Mastodon API: Fix lists leaking private posts

	## [0.9.9999] - 2019-04-05
	### Security
	- Mastodon API: Fix content warnings skipping HTML sanitization

	## [0.9.999] - 2019-03-13
	Frontend changes only.
	### Added
	- Added floating action button for posting status on mobile
	### Changed
	- Changed user-settings icon to a pencil
	### Fixed
	- Keyboard shortcuts activating when typing a message
	- Gaps when scrolling down on a timeline after showing new

	## [0.9.99] - 2019-03-08
	### Changed
	- Update the frontend to the 0.9.99 tag
	### Fixed
	- Sign the date header in federation to fix Mastodon federation.

	## [0.9.9] - 2019-02-22
	This is our first stable release.
	diff --git a/docs/api/admin_api.md b/docs/api/admin_api.md
	index bce5e399b..c429da822 100644
	--- a/docs/api/admin_api.md
	+++ b/docs/api/admin_api.md
	@@ -1,652 +1,654 @@
	# 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,
	"avatar": string,
	"display_name": string
	},
	...
	]
	}
	```

	## `/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_or_id`

	### Retrive the details of a user

	- Method: `GET`
	- Params:
	- `nickname` or `id`
	- 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
	},
	"tags": ["force_unlisted"],
	"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
	},
	"tags": ["force_unlisted"],
	"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,
	+ "key": string or string with leading `:` for atoms,
	"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"`. For keys it is not needed.
	-Integer with `i:`, e.g. `"i:150"`.
	-Tuple with more than 2 values with `{"tuple": ["first_val", Pleroma.Module, []]}`.
	+Atom keys and values can be passed with `:` in the beginning, e.g. `":upload"`.
	+Tuples can be passed as `{"tuple": ["first_val", Pleroma.Module, []]}`.
	`{"tuple": ["some_string", "Pleroma.Some.Module", []]}` will be converted to `{"some_string", Pleroma.Some.Module, []}`.
	+Keywords can be passed as lists with 2 child tuples, e.g.
	+`[{"tuple": ["first_val", Pleroma.Module]}, {"tuple": ["second_val", true]}]`.

	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)
	+ - `key` (string or string with leading `:` for atoms)
	- `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": {
	+ "value": [
	+ {"tuple": [":uploader", "Pleroma.Uploaders.Local"]},
	+ {"tuple": [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
	+ {"tuple": [":link_name", true]},
	+ {"tuple": [":proxy_remote", false]},
	+ {"tuple": [":proxy_opts", [
	+ {"tuple": [":redirect_on_failure", false]},
	+ {"tuple": [":max_body_length", 1048576]},
	+ {"tuple": [":http": [
	+ {"tuple": [":follow_redirect", true]},
	+ {"tuple": [":pool", ":upload"]},
	+ ]]}
	+ ]
	+ ]},
	+ {"tuple": [":dispatch", {
	"tuple": ["/api/v1/streaming", "Pleroma.Web.MastodonAPI.WebsocketHandler", []]
	- }
	- }
	- }
	+ }]}
	+ ]
	+ }
	]
	}

	- Response:

	```json
	{
	configs: [
	{
	"group": string,
	- "key": string,
	+ "key": string or string with leading `:` for atoms,
	"value": string or {} or [] or {"tuple": []}
	}
	]
	}
	```
	diff --git a/lib/pleroma/web/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/admin_api_controller.ex
	index 8b3c3c91f..4a0bf4823 100644
	--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
	+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
	@@ -1,441 +1,441 @@
	# 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_or_id(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
	render_error(conn, :not_found, "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
	render_error(conn, :forbidden, "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
	render_error(conn, :not_found, "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
	- %{"group" => group, "key" => key, "value" => value} ->
	- {:ok, config} = Config.update_or_create(%{group: group, key: key, value: value})
	- config
	-
	%{"group" => group, "key" => key, "delete" => "true"} ->
	{:ok, _} = Config.delete(%{group: group, key: key})
	nil
	+
	+ %{"group" => group, "key" => key, "value" => value} ->
	+ {:ok, config} = Config.update_or_create(%{group: group, key: key, value: value})
	+ config
	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), "false"])
	updated
	else
	[]
	end

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

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

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

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

	def errors(conn, _) do
	conn
	\|> put_status(:internal_server_error)
	\|> json(dgettext("errors", "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 24674abc5..b4eb8e002 100644
	--- a/lib/pleroma/web/admin_api/config.ex
	+++ b/lib/pleroma/web/admin_api/config.ex
	@@ -1,165 +1,152 @@
	# 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
	import Pleroma.Web.Gettext
	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_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, :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(params) do
	%Config{}
	\|> 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(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(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 ->
	err =
	dgettext("errors", "Config with params %{params} not found", params: inspect(params))

	{:error, err}
	end
	end

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

	- @spec from_binary_to_map(binary()) :: any()
	- def from_binary_to_map(binary) do
	+ @spec from_binary_with_convert(binary()) :: any()
	+ def from_binary_with_convert(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(entity) when is_list(entity) do
	+ for v <- entity, into: [], do: do_convert(v)
	+ end

	- defp do_convert(values) when is_list(values), do: for(val <- values, do: do_convert(val))
	+ defp do_convert(entity) when is_map(entity) do
	+ for {k, v} <- entity, into: %{}, do: {do_convert(k), do_convert(v)}
	+ end

	- defp do_convert({k, v} = value) when is_tuple(value),
	- do: %{k => do_convert(v)}
	+ defp do_convert({:dispatch, [entity]}), do: %{"tuple" => [":dispatch", [inspect(entity)]]}

	- defp do_convert(value) when is_tuple(value), do: %{"tuple" => do_convert(Tuple.to_list(value))}
	+ defp do_convert(entity) when is_tuple(entity),
	+ do: %{"tuple" => do_convert(Tuple.to_list(entity))}

	- defp do_convert(value) when is_binary(value) or is_map(value) or is_number(value), do: value
	+ defp do_convert(entity) when is_boolean(entity) or is_number(entity) or is_nil(entity),
	+ do: entity

	- defp do_convert(value) when is_atom(value) do
	- string = to_string(value)
	+ defp do_convert(entity) when is_atom(entity) do
	+ string = to_string(entity)

	if String.starts_with?(string, "Elixir."),
	- do: String.trim_leading(string, "Elixir."),
	- else: value
	+ do: do_convert(string),
	+ else: ":" <> string
	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)}
	+ defp do_convert("Elixir." <> module_name), do: module_name

	- Enum.reject(tuples, fn {_k, v} -> is_nil(v) end)
	- \|> Enum.sort()
	- \|> :erlang.term_to_binary()
	- end
	+ defp do_convert(entity) when is_binary(entity), do: entity

	- def transform(entity) when is_list(entity) do
	- list = Enum.map(entity, &do_transform(&1))
	- :erlang.term_to_binary(list)
	+ @spec transform(any()) :: binary()
	+ def transform(entity) when is_binary(entity) or is_map(entity) or is_list(entity) do
	+ :erlang.term_to_binary(do_transform(entity))
	end

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

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

	- defp do_transform(%{"tuple" => [k, values] = entity}) when length(entity) == 2 do
	- {do_transform(k), do_transform(values)}
	+ defp do_transform(%{"tuple" => [":dispatch", [entity]]}) do
	+ cleaned_string = String.replace(entity, ~r/[^\w\|^{:,[\|^,\|^[\|^\]^}\|^\/\|^\.\|^"]^\s/, "")
	+ {dispatch_settings, []} = Code.eval_string(cleaned_string, [], requires: [], macros: [])
	+ {:dispatch, [dispatch_settings]}
	end

	- defp do_transform(%{"tuple" => values}) do
	- Enum.reduce(values, {}, fn val, acc -> Tuple.append(acc, do_transform(val)) end)
	+ defp do_transform(%{"tuple" => entity}) do
	+ Enum.reduce(entity, {}, 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)}
	-
	- Enum.sort(values)
	+ defp do_transform(entity) when is_map(entity) do
	+ for {k, v} <- entity, into: %{}, do: {do_transform(k), do_transform(v)}
	end

	- defp do_transform(value) when is_list(value) do
	- Enum.map(value, &do_transform(&1))
	+ defp do_transform(entity) when is_list(entity) do
	+ for v <- entity, into: [], do: do_transform(v)
	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
	- String.trim(value)
	+ defp do_transform(entity) when is_binary(entity) do
	+ String.trim(entity)
	\|> do_transform_string()
	end

	- defp do_transform(value), do: value
	-
	- defp do_transform_string(value) when byte_size(value) == 0, do: nil
	-
	- 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)
	+ defp do_transform(entity), do: entity

	- String.starts_with?(value, ":") ->
	- String.replace(value, ":", "") \|> String.to_existing_atom()
	+ defp do_transform_string("~r/" <> pattern) do
	+ pattern = String.trim_trailing(pattern, "/")
	+ ~r/#{pattern}/
	+ end

	- String.starts_with?(value, "i:") ->
	- String.replace(value, "i:", "") \|> String.to_integer()
	+ defp do_transform_string(":" <> atom), do: String.to_atom(atom)

	- true ->
	- value
	- end
	+ defp do_transform_string(value) do
	+ if String.starts_with?(value, "Pleroma") or String.starts_with?(value, "Phoenix"),
	+ do: String.to_existing_atom("Elixir." <> value),
	+ else: value
	end
	end
	diff --git a/lib/pleroma/web/admin_api/views/config_view.ex b/lib/pleroma/web/admin_api/views/config_view.ex
	index a31f1041f..49add0b6e 100644
	--- a/lib/pleroma/web/admin_api/views/config_view.ex
	+++ b/lib/pleroma/web/admin_api/views/config_view.ex
	@@ -1,21 +1,21 @@
	# 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.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)
	+ value: Pleroma.Web.AdminAPI.Config.from_binary_with_convert(config.value)
	}
	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 0e04e7e94..1b71cbff3 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,1679 +1,1873 @@
	# 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.HTML
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MediaProxy
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}

	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" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname)
	},
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => false,
	"tags" => ["foo", "bar"],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	\|> 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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}

	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" => [],
	"avatar" => User.avatar_url(user2) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user2.name \|\| user2.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	},
	%{
	"deactivated" => admin.info.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname)
	},
	%{
	"deactivated" => false,
	"id" => old_admin.id,
	"local" => true,
	"nickname" => old_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"tags" => [],
	"avatar" => User.avatar_url(old_admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(old_admin.name \|\| old_admin.nickname)
	}
	]
	\|> 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" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname)
	},
	%{
	"deactivated" => false,
	"id" => second_admin.id,
	"nickname" => second_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => second_admin.local,
	"tags" => [],
	"avatar" => User.avatar_url(second_admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(second_admin.name \|\| second_admin.nickname)
	}
	]
	\|> 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" => [],
	"avatar" => User.avatar_url(moderator) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(moderator.name \|\| moderator.nickname)
	}
	]
	}
	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"],
	"avatar" => User.avatar_url(user1) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user1.name \|\| user1.nickname)
	},
	%{
	"deactivated" => false,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user2.local,
	"tags" => ["second"],
	"avatar" => User.avatar_url(user2) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user2.name \|\| user2.nickname)
	}
	]
	\|> 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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	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 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: [
	%{group: "pleroma", key: "key1", value: "value1"},
	+ %{
	+ group: "ueberauth",
	+ key: "Ueberauth.Strategy.Twitter.OAuth",
	+ value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
	+ },
	%{
	group: "pleroma",
	key: "key2",
	value: %{
	- "nested_1" => "nested_value1",
	- "nested_2" => [
	- %{"nested_22" => "nested_value222"},
	- %{"nested_33" => %{"nested_44" => "nested_444"}}
	+ ":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"}
	+ %{"nested_4" => true}
	]
	},
	%{
	group: "pleroma",
	key: "key4",
	- value: %{"nested_5" => ":upload", "endpoint" => "https://example.com"}
	+ 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" => "ueberauth",
	+ "key" => "Ueberauth.Strategy.Twitter.OAuth",
	+ "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
	+ },
	%{
	"group" => "pleroma",
	"key" => "key2",
	- "value" => [
	- %{"nested_1" => "nested_value1"},
	- %{
	- "nested_2" => [
	- %{"nested_22" => "nested_value222"},
	- %{"nested_33" => %{"nested_44" => "nested_444"}}
	- ]
	- }
	- ]
	+ "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_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	"group" => "pleroma",
	"key" => "key4",
	- "value" => [%{"endpoint" => "https://example.com"}, %{"nested_5" => "upload"}]
	+ "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) == [
	+ assert Application.get_env(:pleroma, :key2) == %{
	nested_1: "nested_value1",
	nested_2: [
	- [nested_22: "nested_value222"],
	- [nested_33: [nested_44: "nested_444"]]
	+ %{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]
	+ %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
	+ %{"nested_4" => true}
	]

	- assert Application.get_env(:pleroma, :key4) == [
	- endpoint: "https://example.com",
	+ 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")

	+ insert(:config,
	+ group: "ueberauth",
	+ key: "Ueberauth.Strategy.Microsoft.OAuth",
	+ value: :erlang.term_to_binary([])
	+ )
	+
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: config1.group, key: config1.key, value: "another_value"},
	- %{group: config2.group, key: config2.key, delete: "true"}
	+ %{group: config2.group, key: config2.key, delete: "true"},
	+ %{
	+ group: "ueberauth",
	+ key: "Ueberauth.Strategy.Microsoft.OAuth",
	+ 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"
	- }
	+ "value" => [
	+ %{"tuple" => [":enabled", false]},
	+ %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	+ %{"tuple" => [":seconds_valid", 60]},
	+ %{"tuple" => [":path", ""]},
	+ %{"tuple" => [":key1", nil]}
	+ ]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	- %{"enabled" => false},
	- %{"method" => "Pleroma.Captcha.Kocaptcha"},
	- %{"seconds_valid" => 60}
	+ %{"tuple" => [":enabled", false]},
	+ %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	+ %{"tuple" => [":seconds_valid", 60]},
	+ %{"tuple" => [":path", ""]},
	+ %{"tuple" => [":key1", nil]}
	]
	}
	]
	}
	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" => [
	+ ":http",
	+ [
	%{
	"tuple" => [
	- ":_",
	+ ":key2",
	[
	- %{
	- "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", []]
	- }
	+ [
	+ %{
	+ "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",
	+ "tuple" => [
	+ ":http",
	+ [
	+ %{
	+ "tuple" => [
	+ ":key2",
	+ [
	%{
	- "Elixir.Phoenix.Transports.WebSocket" => %{
	- "tuple" => [
	- "Pleroma.Web.Endpoint",
	- "Pleroma.Web.UserSocket",
	- []
	+ "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", []]}
	+ ]
	+ }
	]
	- }
	+ ]
	}
	]
	- },
	- %{
	- "tuple" => [
	- "_",
	- "Phoenix.Endpoint.Cowboy2Handler",
	- %{"Elixir.Pleroma.Web.Endpoint" => []}
	- ]
	+ ]
	+ }
	+ ]
	+ ]
	+ }
	+ ]
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "settings with nesting map", %{conn: conn} do
	+ conn =
	+ post(conn, "/api/pleroma/admin/config", %{
	+ configs: [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "key1",
	+ "value" => [
	+ %{"tuple" => [":key2", "some_val"]},
	+ %{
	+ "tuple" => [
	+ ":key3",
	+ %{
	+ ":max_options" => 20,
	+ ":max_option_chars" => 200,
	+ ":min_expiration" => 0,
	+ ":max_expiration" => 31_536_000,
	+ "nested" => %{
	+ ":max_options" => 20,
	+ ":max_option_chars" => 200,
	+ ":min_expiration" => 0,
	+ ":max_expiration" => 31_536_000
	+ }
	+ }
	+ ]
	+ }
	+ ]
	+ }
	+ ]
	+ })
	+
	+ assert json_response(conn, 200) ==
	+ %{
	+ "configs" => [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "key1",
	+ "value" => [
	+ %{"tuple" => [":key2", "some_val"]},
	+ %{
	+ "tuple" => [
	+ ":key3",
	+ %{
	+ ":max_expiration" => 31_536_000,
	+ ":max_option_chars" => 200,
	+ ":max_options" => 20,
	+ ":min_expiration" => 0,
	+ "nested" => %{
	+ ":max_expiration" => 31_536_000,
	+ ":max_option_chars" => 200,
	+ ":max_options" => 20,
	+ ":min_expiration" => 0
	}
	- ]
	- }
	+ }
	+ ]
	}
	+ ]
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "value as map", %{conn: conn} do
	+ conn =
	+ post(conn, "/api/pleroma/admin/config", %{
	+ configs: [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "key1",
	+ "value" => %{"key" => "some_val"}
	+ }
	+ ]
	+ })
	+
	+ assert json_response(conn, 200) ==
	+ %{
	+ "configs" => [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "key1",
	+ "value" => %{"key" => "some_val"}
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "dispatch setting", %{conn: conn} do
	+ conn =
	+ post(conn, "/api/pleroma/admin/config", %{
	+ configs: [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "Pleroma.Web.Endpoint.NotReal",
	+ "value" => [
	+ %{
	+ "tuple" => [
	+ ":http",
	+ [
	+ %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
	+ %{"tuple" => [":dispatch", ["{:_,
	+ [
	+ {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	+ {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
	+ {Phoenix.Transports.WebSocket,
	+ {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
	+ {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	+ ]}"]]}
	+ ]
	+ ]
	+ }
	+ ]
	+ }
	+ ]
	+ })
	+
	+ dispatch_string =
	+ "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
	+ "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
	+ "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
	+ "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
	+
	+ assert json_response(conn, 200) == %{
	+ "configs" => [
	+ %{
	+ "group" => "pleroma",
	+ "key" => "Pleroma.Web.Endpoint.NotReal",
	+ "value" => [
	+ %{
	+ "tuple" => [
	+ ":http",
	+ [
	+ %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
	+ %{
	+ "tuple" => [
	+ ":dispatch",
	+ [
	+ dispatch_string
	+ ]
	+ ]
	+ }
	+ ]
	+ ]
	}
	]
	}
	]
	}
	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 b281831e3..d41666ef3 100644
	--- a/test/web/admin_api/config_test.exs
	+++ b/test/web/admin_api/config_test.exs
	@@ -1,262 +1,465 @@
	# 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.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_params(%{group: config.group, key: config.key})
	end

	test "create/1" do
	{: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_params(%{group: config.group, key: config.key})
	assert loaded == updated
	end

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

	params = [
	%{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_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(%{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 "boolean" do
	+ binary = Config.transform(false)
	+ assert binary == :erlang.term_to_binary(false)
	+ assert Config.from_binary(binary) == false
	+ end
	+
	+ test "nil" do
	+ binary = Config.transform(nil)
	+ assert binary == :erlang.term_to_binary(nil)
	+ assert Config.from_binary(binary) == nil
	+ end
	+
	+ test "integer" do
	+ binary = Config.transform(150)
	+ assert binary == :erlang.term_to_binary(150)
	+ assert Config.from_binary(binary) == 150
	+ end
	+
	+ test "atom" do
	+ binary = Config.transform(":atom")
	+ assert binary == :erlang.term_to_binary(:atom)
	+ assert Config.from_binary(binary) == :atom
	+ end
	+
	+ test "pleroma module" do
	+ binary = Config.transform("Pleroma.Bookmark")
	+ assert binary == :erlang.term_to_binary(Pleroma.Bookmark)
	+ assert Config.from_binary(binary) == Pleroma.Bookmark
	+ end
	+
	+ test "phoenix module" do
	+ binary = Config.transform("Phoenix.Socket.V1.JSONSerializer")
	+ assert binary == :erlang.term_to_binary(Phoenix.Socket.V1.JSONSerializer)
	+ assert Config.from_binary(binary) == Phoenix.Socket.V1.JSONSerializer
	+ end
	+
	+ test "sigil" do
	+ binary = Config.transform("~r/comp[lL][aA][iI][nN]er/")
	+ assert binary == :erlang.term_to_binary(~r/comp[lL][aA][iI][nN]er/)
	+ assert Config.from_binary(binary) == ~r/comp[lL][aA][iI][nN]er/
	+ end
	+
	+ test "2 child tuple" do
	+ binary = Config.transform(%{"tuple" => ["v1", ":v2"]})
	+ assert binary == :erlang.term_to_binary({"v1", :v2})
	+ assert Config.from_binary(binary) == {"v1", :v2}
	+ end
	+
	+ test "tuple with n childs" do
	+ binary =
	+ Config.transform(%{
	+ "tuple" => [
	+ "v1",
	+ ":v2",
	+ "Pleroma.Bookmark",
	+ 150,
	+ false,
	+ "Phoenix.Socket.V1.JSONSerializer"
	+ ]
	+ })
	+
	+ assert binary ==
	+ :erlang.term_to_binary(
	+ {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	+ )
	+
	+ assert Config.from_binary(binary) ==
	+ {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	+ end
	+
	+ test "tuple with dispatch key" do
	+ binary = Config.transform(%{"tuple" => [":dispatch", ["{:_,
	+ [
	+ {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	+ {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
	+ {Phoenix.Transports.WebSocket,
	+ {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
	+ {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	+ ]}"]]})
	+
	+ assert binary ==
	+ :erlang.term_to_binary(
	+ {:dispatch,
	+ [
	+ {:_,
	+ [
	+ {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	+ {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	+ {Phoenix.Transports.WebSocket,
	+ {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
	+ {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	+ ]}
	+ ]}
	+ )
	+
	+ assert Config.from_binary(binary) ==
	+ {:dispatch,
	+ [
	+ {:_,
	+ [
	+ {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	+ {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	+ {Phoenix.Transports.WebSocket,
	+ {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
	+ {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	+ ]}
	+ ]}
	+ end
	+
	+ test "map with string key" do
	+ binary = Config.transform(%{"key" => "value"})
	+ assert binary == :erlang.term_to_binary(%{"key" => "value"})
	+ assert Config.from_binary(binary) == %{"key" => "value"}
	+ end
	+
	+ test "map with atom key" do
	+ binary = Config.transform(%{":key" => "value"})
	+ assert binary == :erlang.term_to_binary(%{key: "value"})
	+ assert Config.from_binary(binary) == %{key: "value"}
	+ end
	+
	+ test "list of strings" do
	+ binary = Config.transform(["v1", "v2", "v3"])
	+ assert binary == :erlang.term_to_binary(["v1", "v2", "v3"])
	+ assert Config.from_binary(binary) == ["v1", "v2", "v3"]
	+ 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"]
	+ test "list of atoms" do
	+ binary = Config.transform([":v1", ":v2", ":v3"])
	+ assert binary == :erlang.term_to_binary([:v1, :v2, :v3])
	+ assert Config.from_binary(binary) == [:v1, :v2, :v3]
	end

	- test "map" do
	+ test "list of mixed values" do
	binary =
	- Config.transform(%{
	- "types" => "Pleroma.PostgresTypes",
	- "telemetry_event" => ["Pleroma.Repo.Instrumenter"],
	- "migration_lock" => ""
	- })
	+ Config.transform([
	+ "v1",
	+ ":v2",
	+ "Pleroma.Repo",
	+ "Phoenix.Socket.V1.JSONSerializer",
	+ 15,
	+ false
	+ ])
	+
	+ assert binary ==
	+ :erlang.term_to_binary([
	+ "v1",
	+ :v2,
	+ Pleroma.Repo,
	+ Phoenix.Socket.V1.JSONSerializer,
	+ 15,
	+ false
	+ ])
	+
	+ assert Config.from_binary(binary) == [
	+ "v1",
	+ :v2,
	+ Pleroma.Repo,
	+ Phoenix.Socket.V1.JSONSerializer,
	+ 15,
	+ false
	+ ]
	+ end
	+
	+ test "simple keyword" do
	+ binary = Config.transform([%{"tuple" => [":key", "value"]}])
	+ assert binary == :erlang.term_to_binary([{:key, "value"}])
	+ assert Config.from_binary(binary) == [{:key, "value"}]
	+ assert Config.from_binary(binary) == [key: "value"]
	+ end
	+
	+ test "keyword" do
	+ binary =
	+ Config.transform([
	+ %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
	+ %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
	+ %{"tuple" => [":migration_lock", nil]},
	+ %{"tuple" => [":key1", 150]},
	+ %{"tuple" => [":key2", "string"]}
	+ ])

	assert binary ==
	:erlang.term_to_binary(
	+ types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	- types: Pleroma.PostgresTypes
	+ migration_lock: nil,
	+ key1: 150,
	+ key2: "string"
	)

	assert Config.from_binary(binary) == [
	+ types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	- types: Pleroma.PostgresTypes
	+ migration_lock: nil,
	+ key1: 150,
	+ key2: "string"
	]
	end

	- test "complex map with nested integers, lists and atoms" do
	+ test "complex keyword with nested mixed childs" 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"
	- }
	+ Config.transform([
	+ %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
	+ %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
	+ %{"tuple" => [":link_name", true]},
	+ %{"tuple" => [":proxy_remote", false]},
	+ %{"tuple" => [":common_map", %{":key" => "value"}]},
	+ %{
	+ "tuple" => [
	+ ":proxy_opts",
	+ [
	+ %{"tuple" => [":redirect_on_failure", false]},
	+ %{"tuple" => [":max_body_length", 1_048_576]},
	+ %{
	+ "tuple" => [
	+ ":http",
	+ [%{"tuple" => [":follow_redirect", true]}, %{"tuple" => [":pool", ":upload"]}]
	+ ]
	+ }
	+ ]
	+ ]
	}
	- })
	+ ])

	assert binary ==
	:erlang.term_to_binary(
	+ uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	+ proxy_remote: false,
	+ common_map: %{key: "value"},
	proxy_opts: [
	+ redirect_on_failure: false,
	+ max_body_length: 1_048_576,
	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) ==
	[
	+ uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	+ proxy_remote: false,
	+ common_map: %{key: "value"},
	proxy_opts: [
	+ redirect_on_failure: false,
	+ max_body_length: 1_048_576,
	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
	+ test "common keyword" do
	binary =
	- Config.transform(%{
	- "level" => ":warn",
	- "meta" => [":all"],
	- "webhook_url" => "https://hooks.slack.com/services/YOUR-KEY-HERE"
	- })
	+ Config.transform([
	+ %{"tuple" => [":level", ":warn"]},
	+ %{"tuple" => [":meta", [":all"]]},
	+ %{"tuple" => [":path", ""]},
	+ %{"tuple" => [":val", nil]},
	+ %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
	+ ])

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

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

	- test "complex map with sigil" do
	+ test "complex keyword with sigil" do
	binary =
	- Config.transform(%{
	- federated_timeline_removal: [],
	- reject: [~r/comp[lL][aA][iI][nN]er/],
	- replace: []
	- })
	+ Config.transform([
	+ %{"tuple" => [":federated_timeline_removal", []]},
	+ %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
	+ %{"tuple" => [":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
	+ test "complex keyword 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", []]}
	+ Config.transform([
	+ %{
	+ "tuple" => [
	+ ":http",
	+ [
	+ %{
	+ "tuple" => [
	+ ":key1",
	+ [
	+ %{
	+ "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", []]}
	+ ]
	+ }
	]
	- }
	- ]
	- },
	- %{
	- "tuple" => [
	- ":_",
	- "Phoenix.Endpoint.Cowboy2Handler",
	- %{
	- "tuple" => ["Pleroma.Web.Endpoint", []]
	- }
	- ]
	- }
	+ ]
	+ }
	+ ]
	]
	- ]
	- }
	+ }
	+ ]
	]
	}
	- })
	+ ])

	assert binary ==
	:erlang.term_to_binary(
	http: [
	- dispatch: [
	+ key1: [
	_: [
	{"/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: [
	+ key1: [
	{:_,
	[
	{"/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: Fri, Oct 30, 8:23 AM (20 h, 23 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799877
Default Alt Text: (135 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions