No OneTemporary
Actions

Size

433 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index 8692dfef2..dabc2a85a 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,715 +1,716 @@
	# 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
	<details>
	<summary>API Changes</summary>
	- Breaking: Emoji API: changed methods and renamed routes.
	</details>

	### Removed
	- Breaking: removed `with_move` parameter from notifications timeline.

	### Added
	+- ActivityPub: Added support for existing AP ids for instances migrated from Mastodon.
	- Instance: Add `background_image` to configuration and `/api/v1/instance`
	- Instance: Extend `/api/v1/instance` with Pleroma-specific information.
	- NodeInfo: `pleroma:api/v1/notifications:include_types_filter` to the `features` list.
	- NodeInfo: `pleroma_emoji_reactions` to the `features` list.
	- Configuration: `:restrict_unauthenticated` setting, restrict access for unauthenticated users to timelines (public and federate), user profiles and statuses.
	- Configuration: Add `:database_config_whitelist` setting to whitelist settings which can be configured from AdminFE.
	- Configuration: `filename_display_max_length` option to set filename truncate limit, if filename display enabled (0 = no limit).
	- New HTTP adapter [gun](https://github.com/ninenines/gun). Gun adapter requires minimum OTP version of 22.2 otherwise Pleroma won’t start. For hackney OTP update is not required.
	- Mix task to create trusted OAuth App.
	- Notifications: Added `follow_request` notification type.
	- Added `:reject_deletes` group to SimplePolicy
	- MRF (`EmojiStealPolicy`): New MRF Policy which allows to automatically download emojis from remote instances
	<details>
	<summary>API Changes</summary>
	- Mastodon API: Extended `/api/v1/instance`.
	- Mastodon API: Support for `include_types` in `/api/v1/notifications`.
	- Mastodon API: Added `/api/v1/notifications/:id/dismiss` endpoint.
	- Mastodon API: Add support for filtering replies in public and home timelines
	- Admin API: endpoints for create/update/delete OAuth Apps.
	- Admin API: endpoint for status view.
	</details>

	### Fixed
	- Support pagination in conversations API
	- Breaking: SimplePolicy `:reject` and `:accept` allow deletions again
	- Fix follower/blocks import when nicknames starts with @
	- Filtering of push notifications on activities from blocked domains
	- Resolving Peertube accounts with Webfinger

	## [Unreleased (patch)]

	### Fixed
	- Healthcheck reporting the number of memory currently used, rather than allocated in total
	- `InsertSkeletonsForDeletedUsers` failing on some instances

	## [2.0.3] - 2020-05-02

	### Security
	- Disallow re-registration of previously deleted users, which allowed viewing direct messages addressed to them
	- Mastodon API: Fix `POST /api/v1/follow_requests/:id/authorize` allowing to force a follow from a local user even if they didn't request to follow
	- CSP: Sandbox uploads

	### Fixed
	- Notifications from blocked domains
	- Potential federation issues with Mastodon versions before 3.0.0
	- HTTP Basic Authentication permissions issue
	- Follow/Block imports not being able to find the user if the nickname started with an `@`
	- Instance stats counting internal users
	- Inability to run a From Source release without git
	- ObjectAgePolicy didn't filter out old messages
	- `blob:` urls not being allowed by CSP

	### Added
	- NodeInfo: ObjectAgePolicy settings to the `federation` list.
	- Follow request notifications
	<details>
	<summary>API Changes</summary>
	- Admin API: `GET /api/pleroma/admin/need_reboot`.
	</details>

	### Upgrade notes

	1. Restart Pleroma
	2. Run database migrations (inside Pleroma directory):
	- OTP: `./bin/pleroma_ctl migrate`
	- From Source: `mix ecto.migrate`


	## [2.0.2] - 2020-04-08
	### Added
	- Support for Funkwhale's `Audio` activity
	- Admin API: `PATCH /api/pleroma/admin/users/:nickname/update_credentials`

	### Fixed
	- Blocked/muted users still generating push notifications
	- Input textbox for bio ignoring newlines
	- OTP: Inability to use PostgreSQL databases with SSL
	- `user delete_activities` breaking when trying to delete already deleted posts
	- Incorrect URL for Funkwhale channels

	### Upgrade notes
	1. Restart Pleroma

	## [2.0.1] - 2020-03-15
	### Security
	- Static-FE: Fix remote posts not being sanitized

	### Fixed
	- 500 errors when no `Accept` header is present if Static-FE is enabled
	- Instance panel not being updated immediately due to wrong `Cache-Control` headers
	- Statuses posted with BBCode/Markdown having unncessary newlines in Pleroma-FE
	- OTP: Fix some settings not being migrated to in-database config properly
	- No `Cache-Control` headers on attachment/media proxy requests
	- Character limit enforcement being off by 1
	- Mastodon Streaming API: hashtag timelines not working

	### Changed
	- BBCode and Markdown formatters will no longer return any `\n` and only use `<br/>` for newlines
	- Mastodon API: Allow registration without email if email verification is not enabled

	### Upgrade notes
	#### Nginx only
	1. Remove `proxy_ignore_headers Cache-Control;` and `proxy_hide_header Cache-Control;` from your config.

	#### Everyone
	1. Run database migrations (inside Pleroma directory):
	- OTP: `./bin/pleroma_ctl migrate`
	- From Source: `mix ecto.migrate`
	2. Restart Pleroma

	## [2.0.0] - 2019-03-08
	### Security
	- Mastodon API: Fix being able to request enormous amount of statuses in timelines leading to DoS. Now limited to 40 per request.

	### Removed
	- Breaking: Removed 1.0+ deprecated configurations `Pleroma.Upload, :strip_exif` and `:instance, :dedupe_media`
	- Breaking: OStatus protocol support
	- Breaking: MDII uploader
	- Breaking: Using third party engines for user recommendation
	<details>
	<summary>API Changes</summary>
	- Breaking: AdminAPI: migrate_from_db endpoint
	</details>

	### Changed
	- Breaking: Pleroma won't start if it detects unapplied migrations
	- Breaking: Elixir >=1.8 is now required (was >= 1.7)
	- Breaking: `Pleroma.Plugs.RemoteIp` and `:rate_limiter` enabled by default. Please ensure your reverse proxy forwards the real IP!
	- Breaking: attachment links (`config :pleroma, :instance, no_attachment_links` and `config :pleroma, Pleroma.Upload, link_name`) disabled by default
	- Breaking: OAuth: defaulted `[:auth, :enforce_oauth_admin_scope_usage]` setting to `true` which demands `admin` OAuth scope to perform admin actions (in addition to `is_admin` flag on User); make sure to use bundled or newer versions of AdminFE & PleromaFE to access admin / moderator features.
	- Breaking: Dynamic configuration has been rearchitected. The `:pleroma, :instance, dynamic_configuration` setting has been replaced with `config :pleroma, configurable_from_database`. Please backup your configuration to a file and run the migration task to ensure consistency with the new schema.
	- Breaking: `:instance, no_attachment_links` has been replaced with `:instance, attachment_links` which still takes a boolean value but doesn't use double negative language.
	- Replaced [pleroma_job_queue](https://git.pleroma.social/pleroma/pleroma_job_queue) and `Pleroma.Web.Federator.RetryQueue` with [Oban](https://github.com/sorentwo/oban) (see [`docs/config.md`](docs/config.md) on migrating customized worker / retry settings)
	- Introduced [quantum](https://github.com/quantum-elixir/quantum-core) job scheduler
	- Enabled `:instance, extended_nickname_format` in the default config
	- Add `rel="ugc"` to all links in statuses, to prevent SEO spam
	- Extract RSS functionality from OStatus
	- MRF (Simple Policy): Also use `:accept`/`:reject` on the actors rather than only their activities
	- OStatus: Extract RSS functionality
	- Deprecated `User.Info` embedded schema (fields moved to `User`)
	- Store status data inside Flag activity
	- Deprecated (reorganized as `UserRelationship` entity) User fields with user AP IDs (`blocks`, `mutes`, `muted_reblogs`, `muted_notifications`, `subscribers`).
	- Rate limiter is now disabled for localhost/socket (unless remoteip plug is enabled)
	- Logger: default log level changed from `warn` to `info`.
	- Config mix task `migrate_to_db` truncates `config` table before migrating the config file.
	- Allow account registration without an email
	- Default to `prepare: :unnamed` in the database configuration.
	- Instance stats are now loaded on startup instead of being empty until next hourly job.
	<details>
	<summary>API Changes</summary>

	- Breaking EmojiReactions: Change endpoints and responses to align with Mastodon
	- Breaking Admin API: `PATCH /api/pleroma/admin/users/:nickname/force_password_reset` is now `PATCH /api/pleroma/admin/users/force_password_reset` (accepts `nicknames` array in the request body)
	- Breaking: Admin API: Return link alongside with token on password reset
	- Breaking: Admin API: `PUT /api/pleroma/admin/reports/:id` is now `PATCH /api/pleroma/admin/reports`, see admin_api.md for details
	- Breaking: `/api/pleroma/admin/users/invite_token` now uses `POST`, changed accepted params and returns full invite in json instead of only token string.
	- Breaking replying to reports is now "report notes", endpoint changed from `POST /api/pleroma/admin/reports/:id/respond` to `POST /api/pleroma/admin/reports/:id/notes`
	- Mastodon API: stopped sanitizing display names, field names and subject fields since they are supposed to be treated as plaintext
	- Admin API: Return `total` when querying for reports
	- Mastodon API: Return `pleroma.direct_conversation_id` when creating a direct message (`POST /api/v1/statuses`)
	- Admin API: Return link alongside with token on password reset
	- Admin API: Support authentication via `x-admin-token` HTTP header
	- Mastodon API: Add `pleroma.direct_conversation_id` to the status endpoint (`GET /api/v1/statuses/:id`)
	- Mastodon API: `pleroma.thread_muted` to the Status entity
	- Mastodon API: Mark the direct conversation as read for the author when they send a new direct message
	- Mastodon API, streaming: Add `pleroma.direct_conversation_id` to the `conversation` stream event payload.
	- Mastodon API: Add `pleroma.unread_count` to the Marker entity
	- Admin API: Render whole status in grouped reports
	- Mastodon API: User timelines will now respect blocks, unless you are getting the user timeline of somebody you blocked (which would be empty otherwise).
	- Mastodon API: Favoriting / Repeating a post multiple times will now return the identical response every time. Before, executing that action twice would return an error ("already favorited") on the second try.
	- Mastodon API: Limit timeline requests to 3 per timeline per 500ms per user/ip by default.
	- Admin API: `PATCH /api/pleroma/admin/users/:nickname/credentials` and `GET /api/pleroma/admin/users/:nickname/credentials`
	</details>

	### Added
	- `:chat_limit` option to limit chat characters.
	- `cleanup_attachments` option to remove attachments along with statuses. Does not affect duplicate files and attachments without status. Enabling this will increase load to database when deleting statuses on larger instances.
	- Refreshing poll results for remote polls
	- Authentication: Added rate limit for password-authorized actions / login existence checks
	- Static Frontend: Add the ability to render user profiles and notices server-side without requiring JS app.
	- Mix task to re-count statuses for all users (`mix pleroma.count_statuses`)
	- Mix task to list all users (`mix pleroma.user list`)
	- Mix task to send a test email (`mix pleroma.email test`)
	- Support for `X-Forwarded-For` and similar HTTP headers which used by reverse proxies to pass a real user IP address to the backend. Must not be enabled unless your instance is behind at least one reverse proxy (such as Nginx, Apache HTTPD or Varnish Cache).
	- MRF: New module which handles incoming posts based on their age. By default, all incoming posts that are older than 2 days will be unlisted and not shown to their followers.
	- User notification settings: Add `privacy_option` option.
	- Support for custom Elixir modules (such as MRF policies)
	- User settings: Add _This account is a_ option.
	- A new users admin digest email
	- OAuth: admin scopes support (relevant setting: `[:auth, :enforce_oauth_admin_scope_usage]`).
	- Add an option `authorized_fetch_mode` to require HTTP signatures for AP fetches.
	- ActivityPub: support for `replies` collection (output for outgoing federation & fetching on incoming federation).
	- Mix task to refresh counter cache (`mix pleroma.refresh_counter_cache`)
	<details>
	<summary>API Changes</summary>

	- Job queue stats to the healthcheck page
	- Admin API: Add ability to fetch reports, grouped by status `GET /api/pleroma/admin/grouped_reports`
	- Admin API: Add ability to require password reset
	- Mastodon API: Account entities now include `follow_requests_count` (planned Mastodon 3.x addition)
	- Pleroma API: `GET /api/v1/pleroma/accounts/:id/scrobbles` to get a list of recently scrobbled items
	- Pleroma API: `POST /api/v1/pleroma/scrobble` to scrobble a media item
	- Mastodon API: Add `upload_limit`, `avatar_upload_limit`, `background_upload_limit`, and `banner_upload_limit` to `/api/v1/instance`
	- Mastodon API: Add `pleroma.unread_conversation_count` to the Account entity
	- OAuth: support for hierarchical permissions / [Mastodon 2.4.3 OAuth permissions](https://docs.joinmastodon.org/api/permissions/)
	- Metadata Link: Atom syndication Feed
	- Mix task to re-count statuses for all users (`mix pleroma.count_statuses`)
	- Mastodon API: Add `exclude_visibilities` parameter to the timeline and notification endpoints
	- Admin API: `/users/:nickname/toggle_activation` endpoint is now deprecated in favor of: `/users/activate`, `/users/deactivate`, both accept `nicknames` array
	- Admin API: Multiple endpoints now require `nicknames` array, instead of singe `nickname`:
	- `POST/DELETE /api/pleroma/admin/users/:nickname/permission_group/:permission_group` are deprecated in favor of: `POST/DELETE /api/pleroma/admin/users/permission_group/:permission_group`
	- `DELETE /api/pleroma/admin/users` (`nickname` query param or `nickname` sent in JSON body) is deprecated in favor of: `DELETE /api/pleroma/admin/users` (`nicknames` query array param or `nicknames` sent in JSON body)
	- Admin API: Add `GET /api/pleroma/admin/relay` endpoint - lists all followed relays
	- Pleroma API: `POST /api/v1/pleroma/conversations/read` to mark all conversations as read
	- ActivityPub: Support `Move` activities
	- Mastodon API: Add `/api/v1/markers` for managing timeline read markers
	- Mastodon API: Add the `recipients` parameter to `GET /api/v1/conversations`
	- Configuration: `feed` option for user atom feed.
	- Pleroma API: Add Emoji reactions
	- Admin API: Add `/api/pleroma/admin/instances/:instance/statuses` - lists all statuses from a given instance
	- Admin API: Add `/api/pleroma/admin/users/:nickname/statuses` - lists all statuses from a given user
	- Admin API: `PATCH /api/pleroma/users/confirm_email` to confirm email for multiple users, `PATCH /api/pleroma/users/resend_confirmation_email` to resend confirmation email for multiple users
	- ActivityPub: Configurable `type` field of the actors.
	- Mastodon API: `/api/v1/accounts/:id` has `source/pleroma/actor_type` field.
	- Mastodon API: `/api/v1/update_credentials` accepts `actor_type` field.
	- Captcha: Support native provider
	- Captcha: Enable by default
	- Mastodon API: Add support for `account_id` param to filter notifications by the account
	- Mastodon API: Add `emoji_reactions` property to Statuses
	- Mastodon API: Change emoji reaction reply format
	- Notifications: Added `pleroma:emoji_reaction` notification type
	- Mastodon API: Change emoji reaction reply format once more
	- Configuration: `feed.logo` option for tag feed.
	- Tag feed: `/tags/:tag.rss` - list public statuses by hashtag.
	- Mastodon API: Add `reacted` property to `emoji_reactions`
	- Pleroma API: Add reactions for a single emoji.
	- ActivityPub: `[:activitypub, :note_replies_output_limit]` setting sets the number of note self-replies to output on outgoing federation.
	- Admin API: `GET /api/pleroma/admin/stats` to get status count by visibility scope
	- Admin API: `GET /api/pleroma/admin/statuses` - list all statuses (accepts `godmode` and `local_only`)
	</details>

	### Fixed
	- Report emails now include functional links to profiles of remote user accounts
	- Not being able to log in to some third-party apps when logged in to MastoFE
	- MRF: `Delete` activities being exempt from MRF policies
	- OTP releases: Not being able to configure OAuth expired token cleanup interval
	- OTP releases: Not being able to configure HTML sanitization policy
	- OTP releases: Not being able to change upload limit (again)
	- Favorites timeline now ordered by favorite date instead of post date
	- Support for cancellation of a follow request
	<details>
	<summary>API Changes</summary>

	- Mastodon API: Fix private and direct statuses not being filtered out from the public timeline for an authenticated user (`GET /api/v1/timelines/public`)
	- Mastodon API: Inability to get some local users by nickname in `/api/v1/accounts/:id_or_nickname`
	- AdminAPI: If some status received reports both in the "new" format and "old" format it was considered reports on two different statuses (in the context of grouped reports)
	- Admin API: Error when trying to update reports in the "old" format
	- Mastodon API: Marking a conversation as read (`POST /api/v1/conversations/:id/read`) now no longer brings it to the top in the user's direct conversation list
	</details>

	## [1.1.9] - 2020-02-10
	### Fixed
	- OTP: Inability to set the upload limit (again)
	- Not being able to pin polls
	- Streaming API: incorrect handling of reblog mutes
	- Rejecting the user when field length limit is exceeded
	- OpenGraph provider: html entities in descriptions

	## [1.1.8] - 2020-01-10
	### Fixed
	- Captcha generation issues
	- Returned Kocaptcha endpoint to configuration
	- Captcha validity is now 5 minutes

	## [1.1.7] - 2019-12-13
	### Fixed
	- OTP: Inability to set the upload limit
	- OTP: Inability to override node name/distribution type to run 2 Pleroma instances on the same machine

	### Added
	- Integrated captcha provider

	### Changed
	- Captcha enabled by default
	- Default Captcha provider changed from `Pleroma.Captcha.Kocaptcha` to `Pleroma.Captcha.Native`
	- Better `Cache-Control` header for static content

	### Bundled Pleroma-FE Changes
	#### Added
	- Icons in the navigation panel

	#### Fixed
	- Improved support unauthenticated view of private instances

	#### Removed
	- Whitespace hack on empty post content

	## [1.1.6] - 2019-11-19
	### Fixed
	- Not being able to log into to third party apps when the browser is logged into mastofe
	- Email confirmation not being required even when enabled
	- Mastodon API: conversations API crashing when one status is malformed

	### Bundled Pleroma-FE Changes
	#### Added
	- About page
	- Meme arrows

	#### Fixed
	- Image modal not closing unless clicked outside of image
	- Attachment upload spinner not being centered
	- Showing follow counters being 0 when they are actually hidden

	## [1.1.5] - 2019-11-09
	### Fixed
	- Polls having different numbers in timelines/notifications/poll api endpoints due to cache desyncronization
	- Pleroma API: OAuth token endpoint not being found when ".json" suffix is appended

	### Changed
	- Frontend bundle updated to [044c9ad0](https://git.pleroma.social/pleroma/pleroma-fe/commit/044c9ad0562af059dd961d50961a3880fca9c642)

	## [1.1.4] - 2019-11-01
	### Fixed
	- Added a migration that fills up empty user.info fields to prevent breakage after previous unsafe migrations.
	- Failure to migrate from pre-1.0.0 versions
	- Mastodon API: Notification stream not including follow notifications

	## [1.1.3] - 2019-10-25
	### Fixed
	- Blocked users showing up in notifications collapsed as if they were muted
	- `pleroma_ctl` not working on Debian's default shell

	## [1.1.2] - 2019-10-18
	### Fixed
	- `pleroma_ctl` trying to connect to a running instance when generating the config, which of course doesn't exist.

	## [1.1.1] - 2019-10-18
	### Fixed
	- One of the migrations between 1.0.0 and 1.1.0 wiping user info of the relay user because of unexpected behavior of postgresql's `jsonb_set`, resulting in inability to post in the default configuration. If you were affected, please run the following query in postgres console, the relay user will be recreated automatically:
	```
	delete from users where ap_id = 'https://your.instance.hostname/relay';
	```
	- Bad user search matches

	## [1.1.0] - 2019-10-14
	Breaking: The stable branch has been changed from `master` to `stable`. If you want to keep using 1.0, the `release/1.0` branch will receive security updates for 6 months after 1.1 release.

	OTP Note: `pleroma_ctl` in 1.0 defaults to `master` and doesn't support specifying arbitrary branches, making `./pleroma_ctl update` fail. To fix this, fetch a version of `pleroma_ctl` from 1.1 using the command below and proceed with the update normally:
	```
	curl -Lo ./bin/pleroma_ctl 'https://git.pleroma.social/pleroma/pleroma/raw/develop/rel/files/bin/pleroma_ctl'
	```
	### Security
	- Mastodon API: respect post privacy in `/api/v1/statuses/:id/{favourited,reblogged}_by`

	### Removed
	- Breaking: GNU Social API with Qvitter extensions support
	- Emoji: Remove longfox emojis.
	- Remove `Reply-To` header from report emails for admins.
	- ActivityPub: The `/objects/:uuid/likes` endpoint.

	### 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
	- Breaking: Configuration: `/media/` is now removed when `base_url` is configured, append `/media/` to your `base_url` config to keep the old behaviour if desired
	- Breaking: `/api/pleroma/notifications/read` is moved to `/api/v1/pleroma/notifications/read` and now supports `max_id` and responds with Mastodon API entities.
	- Configuration: added `config/description.exs`, from which `docs/config.md` is generated
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- Federation: Return 403 errors when trying to request pages from a user's follower/following collections if they have `hide_followers`/`hide_follows` set
	- NodeInfo: Return `skipThreadContainment` in `metadata` for the `skip_thread_containment` option
	- NodeInfo: Return `mailerEnabled` in `metadata`
	- Mastodon API: Unsubscribe followers when they unfollow a user
	- Mastodon API: `pleroma.thread_muted` key in the Status entity
	- AdminAPI: Add "godmode" while fetching user statuses (i.e. admin can see private statuses)
	- Improve digest email template
	– Pagination: (optional) return `total` alongside with `items` when paginating
	- The `Pleroma.FlakeId` module has been replaced with the `flake_id` library.

	### Fixed
	- Following from Osada
	- Favorites timeline doing database-intensive queries
	- Metadata rendering errors resulting in the entire page being inaccessible
	- `federation_incoming_replies_max_depth` option being ignored in certain cases
	- Mastodon API: Handling of search timeouts (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API: Misskey's endless polls being unable to render
	- Mastodon API: Embedded relationships not being properly rendered in the Account entity of Status entity
	- Mastodon API: Notifications endpoint crashing if one notification failed to render
	- Mastodon API: `exclude_replies` is correctly handled again.
	- Mastodon API: Add `account_id`, `type`, `offset`, and `limit` to search API (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API, streaming: Fix filtering of notifications based on blocks/mutes/thread mutes
	- Mastodon API: Fix private and direct statuses not being filtered out from the public timeline for an authenticated user (`GET /api/v1/timelines/public`)
	- Mastodon API: Ensure the `account` field is not empty when rendering Notification entities.
	- Mastodon API: Inability to get some local users by nickname in `/api/v1/accounts/:id_or_nickname`
	- Mastodon API: Blocks are now treated consistently between the Streaming API and the Timeline APIs
	- Rich Media: Parser failing when no TTL can be found by image TTL setters
	- Rich Media: The crawled URL is now spliced into the rich media data.
	- ActivityPub S2S: sharedInbox usage has been mostly aligned with the rules in the AP specification.
	- ActivityPub C2S: follower/following collection pages being inaccessible even when authentifucated if `hide_followers`/ `hide_follows` was set
	- ActivityPub: Deactivated user deletion
	- ActivityPub: Fix `/users/:nickname/inbox` crashing without an authenticated user
	- MRF: fix ability to follow a relay when AntiFollowbotPolicy was enabled
	- ActivityPub: Correct addressing of Undo.
	- ActivityPub: Correct addressing of profile update activities.
	- ActivityPub: Polls are now refreshed when necessary.
	- Report emails now include functional links to profiles of remote user accounts
	- Existing user id not being preserved on insert conflict
	- Pleroma.Upload base_url was not automatically whitelisted by MediaProxy. Now your custom CDN or file hosting will be accessed directly as expected.
	- Report email not being sent to admins when the reporter is a remote user
	- Reverse Proxy limiting `max_body_length` was incorrectly defined and only checked `Content-Length` headers which may not be sufficient in some circumstances

	### Added
	- Expiring/ephemeral activites. All activities can have expires_at value set, which controls when they should be deleted automatically.
	- Mastodon API: in post_status, the expires_in parameter lets you set the number of seconds until an activity expires. It must be at least one hour.
	- Mastodon API: all status JSON responses contain a `pleroma.expires_at` item which states when an activity will expire. The value is only shown to the user who created the activity. To everyone else it's empty.
	- Configuration: `ActivityExpiration.enabled` controls whether expired activites will get deleted at the appropriate time. Enabled by default.
	- Conversations: Add Pleroma-specific conversation endpoints and status posting extensions. Run the `bump_all_conversations` task again to create the necessary data.
	- MRF: Support for priming the mediaproxy cache (`Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`)
	- MRF: Support for excluding specific domains from Transparency.
	- MRF: Support for filtering posts based on who they mention (`Pleroma.Web.ActivityPub.MRF.MentionPolicy`)
	- 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
	- Mastodon API: Add support for `fields_attributes` API parameter (setting custom fields)
	- Mastodon API: Add support for categories for custom emojis by reusing the group feature. <https://github.com/tootsuite/mastodon/pull/11196>
	- Mastodon API: Add support for muting/unmuting notifications
	- Mastodon API: Add support for the `blocked_by` attribute in the relationship API (`GET /api/v1/accounts/relationships`). <https://github.com/tootsuite/mastodon/pull/10373>
	- Mastodon API: Add support for the `domain_blocking` attribute in the relationship API (`GET /api/v1/accounts/relationships`).
	- Mastodon API: Add `pleroma.deactivated` to the Account entity
	- Mastodon API: added `/auth/password` endpoint for password reset with rate limit.
	- Mastodon API: /api/v1/accounts/:id/statuses now supports nicknames or user id
	- Mastodon API: Improve support for the user profile custom fields
	- Mastodon API: Add support for `fields_attributes` API parameter (setting custom fields)
	- Mastodon API: Added an endpoint to get multiple statuses by IDs (`GET /api/v1/statuses/?ids[]=1&ids[]=2`)
	- 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`.
	- Admin API: Added endpoints to run mix tasks pleroma.config migrate_to_db & pleroma.config migrate_from_db
	- Added synchronization of following/followers counters for external users
	- Configuration: `enabled` option for `Pleroma.Emails.Mailer`, defaulting to `false`.
	- Configuration: Pleroma.Plugs.RateLimiter `bucket_name`, `params` options.
	- Configuration: `user_bio_length` and `user_name_length` options.
	- Addressable lists
	- Twitter API: added rate limit for `/api/account/password_reset` endpoint.
	- ActivityPub: Add an internal service actor for fetching ActivityPub objects.
	- ActivityPub: Optional signing of ActivityPub object fetches.
	- Admin API: Endpoint for fetching latest user's statuses
	- Pleroma API: Add `/api/v1/pleroma/accounts/confirmation_resend?email=<email>` for resending account confirmation.
	- Pleroma API: Email change endpoint.
	- Admin API: Added moderation log
	- Web response cache (currently, enabled for ActivityPub)
	- Reverse Proxy: Do not retry failed requests to limit pressure on the peer

	### Changed
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- Admin API: changed json structure for saving config settings.
	- RichMedia: parsers and their order are configured in `rich_media` config.
	- RichMedia: add the rich media ttl based on image expiration time.

	## [1.0.7] - 2019-09-26
	### Fixed
	- Broken federation on Erlang 22 (previous versions of hackney http client were using an option that got deprecated)
	### Changed
	- ActivityPub: The first page in inboxes/outboxes is no longer embedded.

	## [1.0.6] - 2019-08-14
	### Fixed
	- MRF: fix use of unserializable keyword lists in describe() implementations
	- ActivityPub S2S: POST requests are now signed with `(request-target)` pseudo-header.

	## [1.0.5] - 2019-08-13
	### Fixed
	- Mastodon API: follower/following counters not being nullified, when `hide_follows`/`hide_followers` is set
	- Mastodon API: `muted` in the Status entity, using author's account to determine if the thread was muted
	- Mastodon API: return the actual profile URL in the Account entity's `url` property when appropriate
	- Templates: properly style anchor tags
	- Objects being re-embedded to activities after being updated (e.g faved/reposted). Running 'mix pleroma.database prune_objects' again is advised.
	- Not being able to access the Mastodon FE login page on private instances
	- MRF: ensure that subdomain_match calls are case-insensitive
	- Fix internal server error when using the healthcheck API.

	### Added
	- Breaking: MRF describe API, which adds support for exposing configuration information about MRF policies to NodeInfo.
	Custom modules will need to be updated by adding, at the very least, `def describe, do: {:ok, %{}}` to the MRF policy modules.
	- Relays: Added a task to list relay subscriptions.
	- MRF: Support for filtering posts based on ActivityStreams vocabulary (`Pleroma.Web.ActivityPub.MRF.VocabularyPolicy`)
	- MRF (Simple Policy): Support for wildcard domains.
	- Support for wildcard domains in user domain blocks setting.
	- Configuration: `quarantined_instances` support wildcard domains.
	- Mix Tasks: `mix pleroma.database fix_likes_collections`
	- Configuration: `federation_incoming_replies_max_depth` option

	### Removed
	- Federation: Remove `likes` from objects.
	- Breaking: ActivityPub: The `accept_blocks` configuration setting.

	## [1.0.4] - 2019-08-01
	### Fixed
	- Invalid SemVer version generation, when the current branch does not have commits ahead of tag/checked out on a tag

	## [1.0.3] - 2019-07-31
	### Security
	- OStatus: eliminate the possibility of a protocol downgrade attack.
	- OStatus: prevent following locked accounts, bypassing the approval process.
	- TwitterAPI: use CommonAPI to handle remote follows instead of OStatus.

	## [1.0.2] - 2019-07-28
	### Fixed
	- Not being able to pin unlisted posts
	- Mastodon API: represent poll IDs as strings
	- MediaProxy: fix matching filenames
	- MediaProxy: fix filename encoding
	- Migrations: fix a sporadic migration failure
	- Metadata rendering errors resulting in the entire page being inaccessible
	- Federation/MediaProxy not working with instances that have wrong certificate order
	- ActivityPub S2S: remote user deletions now work the same as local user deletions.

	### Changed
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text

	## [1.0.1] - 2019-07-14
	### Security
	- OStatus: fix an object spoofing vulnerability.

	## [1.0.0] - 2019-06-29
	### Security
	- Mastodon API: Fix display names not being sanitized
	- Rich media: Do not crawl private IP ranges

	### Added
	- Digest email for inactive users
	- 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: `email_notifications` 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`
	- Admin API: `POST /api/pleroma/admin/users` will take list of 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/configuration/postgresql.md b/docs/configuration/postgresql.md
	new file mode 100644
	index 000000000..6983fb459
	--- /dev/null
	+++ b/docs/configuration/postgresql.md
	@@ -0,0 +1,31 @@
	+# Optimizing your PostgreSQL performance
	+
	+Pleroma performance depends to a large extent on good database performance. The default PostgreSQL settings are mostly fine, but often you can get better performance by changing a few settings.
	+
	+You can use [PGTune](https://pgtune.leopard.in.ua) to get recommendations for your setup. If you do, set the "Number of Connections" field to 20, as Pleroma will only use 10 concurrent connections anyway. If you don't, it will give you advice that might even hurt your performance.
	+
	+We also recommend not using the "Network Storage" option.
	+
	+## Example configurations
	+
	+Here are some configuration suggestions for PostgreSQL 10+.
	+
	+### 1GB RAM, 1 CPU
	+```
	+shared_buffers = 256MB
	+effective_cache_size = 768MB
	+maintenance_work_mem = 64MB
	+work_mem = 13107kB
	+```
	+
	+### 2GB RAM, 2 CPU
	+```
	+shared_buffers = 512MB
	+effective_cache_size = 1536MB
	+maintenance_work_mem = 128MB
	+work_mem = 26214kB
	+max_worker_processes = 2
	+max_parallel_workers_per_gather = 1
	+max_parallel_workers = 2
	+```
	+
	diff --git a/docs/installation/otp_en.md b/docs/installation/otp_en.md
	index fb99af699..86135cd20 100644
	--- a/docs/installation/otp_en.md
	+++ b/docs/installation/otp_en.md
	@@ -1,281 +1,281 @@
	# Installing on Linux using OTP releases

	## Pre-requisites
	* A machine running Linux with GNU (e.g. Debian, Ubuntu) or musl (e.g. Alpine) libc and `x86_64`, `aarch64` or `armv7l` CPU, you have root access to. If you are not sure if it's compatible see [Detecting flavour section](#detecting-flavour) below
	* A (sub)domain pointed to the machine

	You will be running commands as root. If you aren't root already, please elevate your priviledges by executing `sudo su`/`su`.

	While in theory OTP releases are possbile to install on any compatible machine, for the sake of simplicity this guide focuses only on Debian/Ubuntu and Alpine.

	### Detecting flavour

	Paste the following into the shell:
	```sh
	arch="$(uname -m)";if [ "$arch" = "x86_64" ];then arch="amd64";elif [ "$arch" = "armv7l" ];then arch="arm";elif [ "$arch" = "aarch64" ];then arch="arm64";else echo "Unsupported arch: $arch">&2;fi;if getconf GNU_LIBC_VERSION>/dev/null;then libc_postfix="";elif [ "$(ldd 2>&1\|head -c 9)" = "musl libc" ];then libc_postfix="-musl";elif [ "$(find /lib/libc.musl*\|wc -l)" ];then libc_postfix="-musl";else echo "Unsupported libc">&2;fi;echo "$arch$libc_postfix"
	```

	If your platform is supported the output will contain the flavour string, you will need it later. If not, this just means that we don't build releases for your platform, you can still try installing from source.

	### Installing the required packages

	Other than things bundled in the OTP release Pleroma depends on:

	* curl (to download the release build)
	* unzip (needed to unpack release builds)
	* ncurses (ERTS won't run without it)
	* PostgreSQL (also utilizes extensions in postgresql-contrib)
	* nginx (could be swapped with another reverse proxy but this guide covers only it)
	* certbot (for Let's Encrypt certificates, could be swapped with another ACME client, but this guide covers only it)

	```sh tab="Alpine"
	echo "http://nl.alpinelinux.org/alpine/latest-stable/community" >> /etc/apk/repositories
	apk update
	apk add curl unzip ncurses postgresql postgresql-contrib nginx certbot
	```

	```sh tab="Debian/Ubuntu"
	apt install curl unzip libncurses5 postgresql postgresql-contrib nginx certbot
	```

	## Setup
	### Configuring PostgreSQL
	#### (Optional) Installing RUM indexes

	!!! warning
	It is recommended to use PostgreSQL v11 or newer. We have seen some minor issues with lower PostgreSQL versions.

	RUM indexes are an alternative indexing scheme that is not included in PostgreSQL by default. You can read more about them on the [Configuration page](../configuration/cheatsheet.md#rum-indexing-for-full-text-search). They are completely optional and most of the time are not worth it, especially if you are running a single user instance (unless you absolutely need ordered search results).

	```sh tab="Alpine"
	apk add git build-base postgresql-dev
	git clone https://github.com/postgrespro/rum /tmp/rum
	cd /tmp/rum
	make USE_PGXS=1
	make USE_PGXS=1 install
	cd
	rm -r /tmp/rum
	```

	```sh tab="Debian/Ubuntu"
	# Available only on Buster/19.04
	apt install postgresql-11-rum
	```

	#### (Optional) Performance configuration
	-For optimal performance, you may use [PGTune](https://pgtune.leopard.in.ua), don't forget to restart postgresql after editing the configuration
	+It is encouraged to check [Optimizing your PostgreSQL performance](../configuration/postgresql.md) document, for tips on PostgreSQL tuning.

	```sh tab="Alpine"
	rc-service postgresql restart
	```

	```sh tab="Debian/Ubuntu"
	systemctl restart postgresql
	```

	If you are using PostgreSQL 12 or higher, add this to your Ecto database configuration

	```elixir
	prepare: :named,
	parameters: [
	plan_cache_mode: "force_custom_plan"
	]
	```

	### Installing Pleroma
	```sh
	# Create a Pleroma user
	adduser --system --shell /bin/false --home /opt/pleroma pleroma

	# Set the flavour environment variable to the string you got in Detecting flavour section.
	# For example if the flavour is `amd64-musl` the command will be
	export FLAVOUR="amd64-musl"

	# Clone the release build into a temporary directory and unpack it
	su pleroma -s $SHELL -lc "
	curl 'https://git.pleroma.social/api/v4/projects/2/jobs/artifacts/stable/download?job=$FLAVOUR' -o /tmp/pleroma.zip
	unzip /tmp/pleroma.zip -d /tmp/
	"

	# Move the release to the home directory and delete temporary files
	su pleroma -s $SHELL -lc "
	mv /tmp/release/* /opt/pleroma
	rmdir /tmp/release
	rm /tmp/pleroma.zip
	"
	# Create uploads directory and set proper permissions (skip if planning to use a remote uploader)
	# Note: It does not have to be `/var/lib/pleroma/uploads`, the config generator will ask about the upload directory later

	mkdir -p /var/lib/pleroma/uploads
	chown -R pleroma /var/lib/pleroma

	# Create custom public files directory (custom emojis, frontend bundle overrides, robots.txt, etc.)
	# Note: It does not have to be `/var/lib/pleroma/static`, the config generator will ask about the custom public files directory later
	mkdir -p /var/lib/pleroma/static
	chown -R pleroma /var/lib/pleroma

	# Create a config directory
	mkdir -p /etc/pleroma
	chown -R pleroma /etc/pleroma

	# Run the config generator
	su pleroma -s $SHELL -lc "./bin/pleroma_ctl instance gen --output /etc/pleroma/config.exs --output-psql /tmp/setup_db.psql"

	# Create the postgres database
	su postgres -s $SHELL -lc "psql -f /tmp/setup_db.psql"

	# Create the database schema
	su pleroma -s $SHELL -lc "./bin/pleroma_ctl migrate"

	# If you have installed RUM indexes uncommend and run
	# su pleroma -s $SHELL -lc "./bin/pleroma_ctl migrate --migrations-path priv/repo/optional_migrations/rum_indexing/"

	# Start the instance to verify that everything is working as expected
	su pleroma -s $SHELL -lc "./bin/pleroma daemon"

	# Wait for about 20 seconds and query the instance endpoint, if it shows your uri, name and email correctly, you are configured correctly
	sleep 20 && curl http://localhost:4000/api/v1/instance

	# Stop the instance
	su pleroma -s $SHELL -lc "./bin/pleroma stop"
	```

	### Setting up nginx and getting Let's Encrypt SSL certificaties

	#### Get a Let's Encrypt certificate
	```sh
	certbot certonly --standalone --preferred-challenges http -d yourinstance.tld
	```

	#### Copy Pleroma nginx configuration to the nginx folder

	The location of nginx configs is dependent on the distro

	```sh tab="Alpine"
	cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/conf.d/pleroma.conf
	```

	```sh tab="Debian/Ubuntu"
	cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/pleroma.conf
	ln -s /etc/nginx/sites-available/pleroma.conf /etc/nginx/sites-enabled/pleroma.conf
	```

	If your distro does not have either of those you can append `include /etc/nginx/pleroma.conf` to the end of the http section in /etc/nginx/nginx.conf and
	```sh
	cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/pleroma.conf
	```

	#### Edit the nginx config
	```sh
	# Replace example.tld with your (sub)domain
	$EDITOR path-to-nginx-config

	# Verify that the config is valid
	nginx -t
	```
	#### Start nginx

	```sh tab="Alpine"
	rc-service nginx start
	```

	```sh tab="Debian/Ubuntu"
	systemctl start nginx
	```

	At this point if you open your (sub)domain in a browser you should see a 502 error, that's because Pleroma is not started yet.

	### Setting up a system service

	```sh tab="Alpine"
	# Copy the service into a proper directory
	cp /opt/pleroma/installation/init.d/pleroma /etc/init.d/pleroma

	# Start pleroma and enable it on boot
	rc-service pleroma start
	rc-update add pleroma
	```

	```sh tab="Debian/Ubuntu"
	# Copy the service into a proper directory
	cp /opt/pleroma/installation/pleroma.service /etc/systemd/system/pleroma.service

	# Start pleroma and enable it on boot
	systemctl start pleroma
	systemctl enable pleroma
	```

	If everything worked, you should see Pleroma-FE when visiting your domain. If that didn't happen, try reviewing the installation steps, starting Pleroma in the foreground and seeing if there are any errrors.

	Still doesn't work? Feel free to contact us on [#pleroma on freenode](https://irc.pleroma.social) or via matrix at <https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org>, you can also [file an issue on our Gitlab](https://git.pleroma.social/pleroma/pleroma-support/issues/new)

	## Post installation

	### Setting up auto-renew of the Let's Encrypt certificate
	```sh
	# Create the directory for webroot challenges
	mkdir -p /var/lib/letsencrypt

	# Uncomment the webroot method
	$EDITOR path-to-nginx-config

	# Verify that the config is valid
	nginx -t
	```

	```sh tab="Alpine"
	# Restart nginx
	rc-service nginx restart

	# Start the cron daemon and make it start on boot
	rc-service crond start
	rc-update add crond

	# Ensure the webroot menthod and post hook is working
	certbot renew --cert-name yourinstance.tld --webroot -w /var/lib/letsencrypt/ --dry-run --post-hook 'rc-service nginx reload'

	# Add it to the daily cron
	echo '#!/bin/sh
	certbot renew --cert-name yourinstance.tld --webroot -w /var/lib/letsencrypt/ --post-hook "rc-service nginx reload"
	' > /etc/periodic/daily/renew-pleroma-cert
	chmod +x /etc/periodic/daily/renew-pleroma-cert

	# If everything worked the output should contain /etc/cron.daily/renew-pleroma-cert
	run-parts --test /etc/periodic/daily
	```

	```sh tab="Debian/Ubuntu"
	# Restart nginx
	systemctl restart nginx

	# Ensure the webroot menthod and post hook is working
	certbot renew --cert-name yourinstance.tld --webroot -w /var/lib/letsencrypt/ --dry-run --post-hook 'systemctl reload nginx'

	# Add it to the daily cron
	echo '#!/bin/sh
	certbot renew --cert-name yourinstance.tld --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
	' > /etc/cron.daily/renew-pleroma-cert
	chmod +x /etc/cron.daily/renew-pleroma-cert

	# If everything worked the output should contain /etc/cron.daily/renew-pleroma-cert
	run-parts --test /etc/cron.daily
	```

	## Create your first user and set as admin
	```sh
	cd /opt/pleroma/bin
	su pleroma -s $SHELL -lc "./bin/pleroma_ctl user new joeuser joeuser@sld.tld --admin"
	```
	This will create an account withe the username of 'joeuser' with the email address of joeuser@sld.tld, and set that user's account as an admin. This will result in a link that you can paste into the browser, which logs you in and enables you to set the password.

	## Further reading

	* [Backup your instance](../administration/backup.md)
	* [Hardening your instance](../configuration/hardening.md)
	* [How to activate mediaproxy](../configuration/howto_mediaproxy.md)
	* [Updating your instance](../administration/updating.md)

	## Questions

	Questions about the installation or didn’t it work as it should be, ask in [#pleroma:matrix.org](https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org) or IRC Channel #pleroma on Freenode.

	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 2cea55285..0fe71694a 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1452 +1,1465 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Config
	alias Pleroma.Constants
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.Upload
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.WebFinger
	alias Pleroma.Workers.BackgroundWorker

	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	import Pleroma.Web.ActivityPub.Visibility

	require Logger
	require Pleroma.Constants

	# For Announce activities, we filter the recipients based on following status for any actors
	# that match actual users. See issue #164 for more information about why this is necessary.
	defp get_recipients(%{"type" => "Announce"} = data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	actor = User.get_cached_by_ap_id(data["actor"])

	recipients =
	Enum.filter(Enum.concat([to, cc, bcc]), fn recipient ->
	case User.get_cached_by_ap_id(recipient) do
	nil -> true
	user -> User.following?(user, actor)
	end
	end)

	{recipients, to, cc}
	end

	defp get_recipients(%{"type" => "Create"} = data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	actor = Map.get(data, "actor", [])
	recipients = [to, cc, bcc, [actor]] \|> Enum.concat() \|> Enum.uniq()
	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = Map.get(data, "to", [])
	cc = Map.get(data, "cc", [])
	bcc = Map.get(data, "bcc", [])
	recipients = Enum.concat([to, cc, bcc])
	{recipients, to, cc}
	end

	defp check_actor_is_active(actor) do
	if not is_nil(actor) do
	with user <- User.get_cached_by_ap_id(actor),
	false <- user.deactivated do
	true
	else
	_e -> false
	end
	else
	true
	end
	end

	defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
	limit = Config.get([:instance, :remote_limit])
	String.length(content) <= limit
	end

	defp check_remote_limit(_), do: true

	def increase_note_count_if_public(actor, object) do
	if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
	end

	def decrease_note_count_if_public(actor, object) do
	if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
	end

	def increase_replies_count_if_reply(%{
	"object" => %{"inReplyTo" => reply_ap_id} = object,
	"type" => "Create"
	}) do
	if is_public?(object) do
	Object.increase_replies_count(reply_ap_id)
	end
	end

	def increase_replies_count_if_reply(_create_data), do: :noop

	def decrease_replies_count_if_reply(%Object{
	data: %{"inReplyTo" => reply_ap_id} = object
	}) do
	if is_public?(object) do
	Object.decrease_replies_count(reply_ap_id)
	end
	end

	def decrease_replies_count_if_reply(_object), do: :noop

	def increase_poll_votes_if_vote(%{
	"object" => %{"inReplyTo" => reply_ap_id, "name" => name},
	"type" => "Create",
	"actor" => actor
	}) do
	Object.increase_vote_count(reply_ap_id, name, actor)
	end

	def increase_poll_votes_if_vote(_create_data), do: :noop

	@spec persist(map(), keyword()) :: {:ok, Activity.t() \| Object.t()}
	def persist(object, meta) do
	with local <- Keyword.fetch!(meta, :local),
	{recipients, _, _} <- get_recipients(object),
	{:ok, activity} <-
	Repo.insert(%Activity{
	data: object,
	local: local,
	recipients: recipients,
	actor: object["actor"]
	}) do
	{:ok, activity, meta}
	end
	end

	@spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map, fake),
	true <- bypass_actor_check \|\| check_actor_is_active(map["actor"]),
	{_, true} <- {:remote_limit_error, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	{recipients, _, _} = get_recipients(map),
	{:fake, false, map, recipients} <- {:fake, fake, map, recipients},
	{:containment, :ok} <- {:containment, Containment.contain_child(map)},
	{:ok, map, object} <- insert_full_object(map) do
	{:ok, activity} =
	Repo.insert(%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients
	})

	# Splice in the child object if we have one.
	activity =
	if not is_nil(object) do
	Map.put(activity, :object, object)
	else
	activity
	end

	BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})

	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

	{:fake, true, map, recipients} ->
	activity = %Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients,
	id: "pleroma:fakeid"
	}

	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	{:ok, activity}

	error ->
	{:error, error}
	end
	end

	def notify_and_stream(activity) do
	Notification.create_notifications(activity)

	conversation = create_or_bump_conversation(activity, activity.actor)
	participations = get_participations(conversation)
	stream_out(activity)
	stream_out_participations(participations)
	end

	defp create_or_bump_conversation(activity, actor) do
	with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
	%User{} = user <- User.get_cached_by_ap_id(actor),
	Participation.mark_as_read(user, conversation) do
	{:ok, conversation}
	end
	end

	defp get_participations({:ok, conversation}) do
	conversation
	\|> Repo.preload(:participations, force: true)
	\|> Map.get(:participations)
	end

	defp get_participations(_), do: []

	def stream_out_participations(participations) do
	participations =
	participations
	\|> Repo.preload(:user)

	Streamer.stream("participation", participations)
	end

	def stream_out_participations(%Object{data: %{"context" => context}}, user) do
	with %Conversation{} = conversation <- Conversation.get_for_ap_id(context),
	conversation = Repo.preload(conversation, :participations),
	last_activity_id =
	fetch_latest_activity_id_for_context(conversation.ap_id, %{
	"user" => user,
	"blocking_user" => user
	}) do
	if last_activity_id do
	stream_out_participations(conversation.participations)
	end
	end
	end

	def stream_out_participations(_, _), do: :noop

	def stream_out(%Activity{data: %{"type" => data_type}} = activity)
	when data_type in ["Create", "Announce", "Delete"] do
	activity
	\|> Topics.get_activity_topics()
	\|> Streamer.stream(activity)
	end

	def stream_out(_activity) do
	:noop
	end

	@spec create(map(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def create(params, fake \\ false) do
	with {:ok, result} <- Repo.transaction(fn -> do_create(params, fake) end) do
	result
	end
	end

	defp do_create(%{to: to, actor: actor, context: context, object: object} = params, fake) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]
	quick_insert? = Config.get([:env]) == :benchmark

	with create_data <-
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	_ <- increase_poll_votes_if_vote(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

	{:fake, true, activity} ->
	{:ok, activity}

	{:error, message} ->
	Repo.rollback(message)
	end
	end

	@spec listen(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def listen(%{to: to, actor: actor, context: context, object: object} = params) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	with listen_data <-
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(listen_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec accept(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def accept(params) do
	accept_or_reject("Accept", params)
	end

	@spec reject(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def reject(params) do
	accept_or_reject("Reject", params)
	end

	@spec accept_or_reject(String.t(), map()) :: {:ok, Activity.t()} \| {:error, any()}
	def accept_or_reject(type, %{to: to, actor: actor, object: object} = params) do
	local = Map.get(params, :local, true)
	activity_id = Map.get(params, :activity_id, nil)

	with data <-
	%{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
	\|> Utils.maybe_put("id", activity_id),
	{:ok, activity} <- insert(data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec update(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
	local = !(params[:local] == false)
	activity_id = params[:activity_id]

	with data <- %{
	"to" => to,
	"cc" => cc,
	"type" => "Update",
	"actor" => actor,
	"object" => object
	},
	data <- Utils.maybe_put(data, "id", activity_id),
	{:ok, activity} <- insert(data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	@spec follow(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| {:error, any()}
	def follow(follower, followed, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_follow(follower, followed, activity_id, local) end) do
	result
	end
	end

	defp do_follow(follower, followed, activity_id, local) do
	with data <- make_follow_data(follower, followed, activity_id),
	{:ok, activity} <- insert(data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec unfollow(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| nil \| {:error, any()}
	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_unfollow(follower, followed, activity_id, local) end) do
	result
	end
	end

	defp do_unfollow(follower, followed, activity_id, local) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	nil -> nil
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec block(User.t(), User.t(), String.t() \| nil, boolean()) ::
	{:ok, Activity.t()} \| {:error, any()}
	def block(blocker, blocked, activity_id \\ nil, local \\ true) do
	with {:ok, result} <-
	Repo.transaction(fn -> do_block(blocker, blocked, activity_id, local) end) do
	result
	end
	end

	defp do_block(blocker, blocked, activity_id, local) do
	unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])

	if unfollow_blocked do
	follow_activity = fetch_latest_follow(blocker, blocked)
	if follow_activity, do: unfollow(blocker, blocked, nil, local)
	end

	with block_data <- make_block_data(blocker, blocked, activity_id),
	{:ok, activity} <- insert(block_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

	@spec flag(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def flag(
	%{
	actor: actor,
	context: _context,
	account: account,
	statuses: statuses,
	content: content
	} = params
	) do
	# only accept false as false value
	local = !(params[:local] == false)
	forward = !(params[:forward] == false)

	additional = params[:additional] \|\| %{}

	additional =
	if forward do
	Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
	else
	Map.merge(additional, %{"to" => [], "cc" => []})
	end

	with flag_data <- make_flag_data(params, additional),
	{:ok, activity} <- insert(flag_data, local),
	{:ok, stripped_activity} <- strip_report_status_data(activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(stripped_activity) do
	User.all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	end
	end

	@spec move(User.t(), User.t(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def move(%User{} = origin, %User{} = target, local \\ true) do
	params = %{
	"type" => "Move",
	"actor" => origin.ap_id,
	"object" => origin.ap_id,
	"target" => target.ap_id
	}

	with true <- origin.ap_id in target.also_known_as,
	{:ok, activity} <- insert(params, local),
	_ <- notify_and_stream(activity) do
	maybe_federate(activity)

	BackgroundWorker.enqueue("move_following", %{
	"origin_id" => origin.id,
	"target_id" => target.id
	})

	{:ok, activity}
	else
	false -> {:error, "Target account must have the origin in `alsoKnownAs`"}
	err -> err
	end
	end

	def fetch_activities_for_context_query(context, opts) do
	public = [Constants.as_public()]

	recipients =
	if opts["user"],
	do: [opts["user"].ap_id \| User.following(opts["user"])] ++ public,
	else: public

	from(activity in Activity)
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> restrict_blocked(opts)
	\|> restrict_recipients(recipients, opts["user"])
	\|> where(
	[activity],
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	)
	)
	\|> exclude_poll_votes(opts)
	\|> exclude_id(opts)
	\|> order_by([activity], desc: activity.id)
	end

	@spec fetch_activities_for_context(String.t(), keyword() \| map()) :: [Activity.t()]
	def fetch_activities_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(opts)
	\|> Repo.all()
	end

	@spec fetch_latest_activity_id_for_context(String.t(), keyword() \| map()) ::
	FlakeId.Ecto.CompatType.t() \| nil
	def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(Map.merge(%{"skip_preload" => true}, opts))
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

	- @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
	- def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	+ @spec fetch_public_or_unlisted_activities(map(), Pagination.type()) :: [Activity.t()]
	+ def fetch_public_or_unlisted_activities(opts \\ %{}, pagination \\ :keyset) do
	opts = Map.drop(opts, ["user"])

	- [Constants.as_public()]
	- \|> fetch_activities_query(opts)
	- \|> restrict_unlisted()
	- \|> Pagination.fetch_paginated(opts, pagination)
	+ query = fetch_activities_query([Constants.as_public()], opts)
	+
	+ query =
	+ if opts["restrict_unlisted"] do
	+ restrict_unlisted(query)
	+ else
	+ query
	+ end
	+
	+ Pagination.fetch_paginated(query, opts, pagination)
	+ end
	+
	+ @spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
	+ def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	+ opts
	+ \|> Map.put("restrict_unlisted", true)
	+ \|> fetch_public_or_unlisted_activities(pagination)
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	query =
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)

	query
	else
	Logger.error("Could not restrict visibility to #{visibility}")
	end
	end

	defp restrict_visibility(query, %{visibility: visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

	defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end
	end

	defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
	when visibility in @valid_visibilities do
	from(
	a in query,
	where:
	not fragment(
	"activity_visibility(?, ?, ?) = ?",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	end

	defp exclude_visibility(query, %{"exclude_visibilities" => visibility})
	when visibility not in [nil \| @valid_visibilities] do
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end

	defp exclude_visibility(query, _visibility), do: query

	defp restrict_thread_visibility(query, _, %{skip_thread_containment: true} = _),
	do: query

	defp restrict_thread_visibility(
	query,
	%{"user" => %User{skip_thread_containment: true}},
	_
	),
	do: query

	defp restrict_thread_visibility(query, %{"user" => %User{ap_id: ap_id}}, _) do
	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
	)
	end

	defp restrict_thread_visibility(query, _, _), do: query

	def fetch_user_abstract_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put("user", reading_user)
	\|> Map.put("actor_id", user.ap_id)

	recipients =
	user_activities_recipients(%{
	"godmode" => params["godmode"],
	"reading_user" => reading_user
	})

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	def fetch_user_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("user", reading_user)
	\|> Map.put("actor_id", user.ap_id)
	\|> Map.put("pinned_activity_ids", user.pinned_activities)

	params =
	if User.blocks?(reading_user, user) do
	params
	else
	params
	\|> Map.put("blocking_user", reading_user)
	\|> Map.put("muting_user", reading_user)
	end

	recipients =
	user_activities_recipients(%{
	"godmode" => params["godmode"],
	"reading_user" => reading_user
	})

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	def fetch_statuses(reading_user, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])

	recipients =
	user_activities_recipients(%{
	"godmode" => params["godmode"],
	"reading_user" => reading_user
	})

	fetch_activities(recipients, params, :offset)
	\|> Enum.reverse()
	end

	defp user_activities_recipients(%{"godmode" => true}) do
	[]
	end

	defp user_activities_recipients(%{"reading_user" => reading_user}) do
	if reading_user do
	[Constants.as_public()] ++ [reading_user.ap_id \| User.following(reading_user)]
	else
	[Constants.as_public()]
	end
	end

	defp restrict_since(query, %{"since_id" => ""}), do: query

	defp restrict_since(query, %{"since_id" => since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
	when is_list(tag_reject) and tag_reject != [] do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'tag' \\?\| (?)", object.data, ^tag_reject)
	)
	end

	defp restrict_tag_reject(query, _), do: query

	defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag_all(query, %{"tag_all" => tag_all})
	when is_list(tag_all) and tag_all != [] do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
	)
	end

	defp restrict_tag_all(query, _), do: query

	defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\?\| (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, _), do: query

	defp restrict_recipients(query, [], _user), do: query

	defp restrict_recipients(query, recipients, nil) do
	from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
	end

	defp restrict_recipients(query, recipients, user) do
	from(
	activity in query,
	where: fragment("? && ?", ^recipients, activity.recipients),
	or_where: activity.actor == ^user.ap_id
	)
	end

	defp restrict_local(query, %{"local_only" => true}) do
	from(activity in query, where: activity.local == true)
	end

	defp restrict_local(query, _), do: query

	defp restrict_actor(query, %{"actor_id" => actor_id}) do
	from(activity in query, where: activity.actor == ^actor_id)
	end

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{"type" => type}) when is_binary(type) do
	from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
	end

	defp restrict_type(query, %{"type" => type}) do
	from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
	end

	defp restrict_type(query, _), do: query

	defp restrict_state(query, %{"state" => state}) do
	from(activity in query, where: fragment("?->>'state' = ?", activity.data, ^state))
	end

	defp restrict_state(query, _), do: query

	defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
	from(
	[_activity, object] in query,
	where: fragment("(?)->'likes' \\? (?)", object.data, ^ap_id)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_media(query, %{"only_media" => val}) when val in [true, "true", "1"] do
	from(
	[_activity, object] in query,
	where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

	defp restrict_replies(query, %{"exclude_replies" => val}) when val in [true, "true", "1"] do
	from(
	[_activity, object] in query,
	where: fragment("?->>'inReplyTo' is null", object.data)
	)
	end

	defp restrict_replies(query, %{
	"reply_filtering_user" => user,
	"reply_visibility" => "self"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'inReplyTo' is null OR ? = ANY(?)",
	object.data,
	^user.ap_id,
	activity.recipients
	)
	)
	end

	defp restrict_replies(query, %{
	"reply_filtering_user" => user,
	"reply_visibility" => "following"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
	object.data,
	^[user.ap_id \| User.get_cached_user_friends_ap_ids(user)],
	activity.recipients,
	activity.actor,
	activity.actor,
	^user.ap_id
	)
	)
	end

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val in [true, "true", "1"] do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query

	defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
	mutes = opts["muted_users_ap_ids"] \|\| User.muted_users_ap_ids(user)

	query =
	from([activity] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
	where: fragment("not (?->'to' \\?\| ?)", activity.data, ^mutes)
	)

	unless opts["skip_preload"] do
	from([thread_mute: tm] in query, where: is_nil(tm.user_id))
	else
	query
	end
	end

	defp restrict_muted(query, _), do: query

	defp restrict_blocked(query, %{"blocking_user" => %User{} = user} = opts) do
	blocked_ap_ids = opts["blocked_users_ap_ids"] \|\| User.blocked_users_ap_ids(user)
	domain_blocks = user.domain_blocks \|\| []

	following_ap_ids = User.get_friends_ap_ids(user)

	query =
	if has_named_binding?(query, :object), do: query, else: Activity.with_joined_object(query)

	from(
	[activity, object: o] in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
	where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocked_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
	activity.actor,
	^domain_blocks,
	activity.actor,
	^following_ap_ids
	),
	where:
	fragment(
	"(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
	o.data,
	^domain_blocks,
	o.data,
	^following_ap_ids
	)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_unlisted(query) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^[Constants.as_public()]
	)
	)
	end

	# TODO: when all endpoints migrated to OpenAPI compare `pinned` with `true` (boolean) only,
	# the same for `restrict_media/2`, `restrict_replies/2`, 'restrict_reblogs/2'
	# and `restrict_muted/2`

	defp restrict_pinned(query, %{"pinned" => pinned, "pinned_activity_ids" => ids})
	when pinned in [true, "true", "1"] do
	from(activity in query, where: activity.id in ^ids)
	end

	defp restrict_pinned(query, _), do: query

	defp restrict_muted_reblogs(query, %{"muting_user" => %User{} = user} = opts) do
	muted_reblogs = opts["reblog_muted_users_ap_ids"] \|\| User.reblog_muted_users_ap_ids(user)

	from(
	activity in query,
	where:
	fragment(
	"not ( ?->>'type' = 'Announce' and ? = ANY(?))",
	activity.data,
	activity.actor,
	^muted_reblogs
	)
	)
	end

	defp restrict_muted_reblogs(query, _), do: query

	defp restrict_instance(query, %{"instance" => instance}) do
	users =
	from(
	u in User,
	select: u.ap_id,
	where: fragment("? LIKE ?", u.nickname, ^"%@#{instance}")
	)
	\|> Repo.all()

	from(activity in query, where: activity.actor in ^users)
	end

	defp restrict_instance(query, _), do: query

	defp exclude_poll_votes(query, %{"include_poll_votes" => true}), do: query

	defp exclude_poll_votes(query, _) do
	if has_named_binding?(query, :object) do
	from([activity, object: o] in query,
	where: fragment("not(?->>'type' = ?)", o.data, "Answer")
	)
	else
	query
	end
	end

	defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
	from(activity in query, where: activity.id != ^id)
	end

	defp exclude_id(query, _), do: query

	defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query

	defp maybe_preload_objects(query, _) do
	query
	\|> Activity.with_preloaded_object()
	end

	defp maybe_preload_bookmarks(query, %{"skip_preload" => true}), do: query

	defp maybe_preload_bookmarks(query, opts) do
	query
	\|> Activity.with_preloaded_bookmark(opts["user"])
	end

	defp maybe_preload_report_notes(query, %{"preload_report_notes" => true}) do
	query
	\|> Activity.with_preloaded_report_notes()
	end

	defp maybe_preload_report_notes(query, _), do: query

	defp maybe_set_thread_muted_field(query, %{"skip_preload" => true}), do: query

	defp maybe_set_thread_muted_field(query, opts) do
	query
	\|> Activity.with_set_thread_muted_field(opts["muting_user"] \|\| opts["user"])
	end

	defp maybe_order(query, %{order: :desc}) do
	query
	\|> order_by(desc: :id)
	end

	defp maybe_order(query, %{order: :asc}) do
	query
	\|> order_by(asc: :id)
	end

	defp maybe_order(query, _), do: query

	defp fetch_activities_query_ap_ids_ops(opts) do
	source_user = opts["muting_user"]
	ap_id_relationships = if source_user, do: [:mute, :reblog_mute], else: []

	ap_id_relationships =
	ap_id_relationships ++
	if opts["blocking_user"] && opts["blocking_user"] == source_user do
	[:block]
	else
	[]
	end

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)

	restrict_blocked_opts = Map.merge(%{"blocked_users_ap_ids" => preloaded_ap_ids[:block]}, opts)
	restrict_muted_opts = Map.merge(%{"muted_users_ap_ids" => preloaded_ap_ids[:mute]}, opts)

	restrict_muted_reblogs_opts =
	Map.merge(%{"reblog_muted_users_ap_ids" => preloaded_ap_ids[:reblog_mute]}, opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
	end

	def fetch_activities_query(recipients, opts \\ %{}) do
	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
	fetch_activities_query_ap_ids_ops(opts)

	config = %{
	skip_thread_containment: Config.get([:instance, :skip_thread_containment])
	}

	Activity
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_preload_report_notes(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> maybe_order(opts)
	\|> restrict_recipients(recipients, opts["user"])
	\|> restrict_replies(opts)
	\|> restrict_tag(opts)
	\|> restrict_tag_reject(opts)
	\|> restrict_tag_all(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_state(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(restrict_blocked_opts)
	\|> restrict_muted(restrict_muted_opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_thread_visibility(opts, config)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(restrict_muted_reblogs_opts)
	\|> restrict_instance(opts)
	\|> Activity.restrict_deactivated_users()
	\|> exclude_poll_votes(opts)
	\|> exclude_visibility(opts)
	end

	def fetch_activities(recipients, opts \\ %{}, pagination \\ :keyset) do
	list_memberships = Pleroma.List.memberships(opts["user"])

	fetch_activities_query(recipients ++ list_memberships, opts)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	\|> maybe_update_cc(list_memberships, opts["user"])
	end

	@doc """
	Fetch favorites activities of user with order by sort adds to favorites
	"""
	@spec fetch_favourites(User.t(), map(), Pagination.type()) :: list(Activity.t())
	def fetch_favourites(user, params \\ %{}, pagination \\ :keyset) do
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Like")
	\|> Activity.with_joined_object()
	\|> Object.with_joined_activity()
	\|> select([_like, object, activity], %{activity \| object: object})
	\|> order_by([like, _, _], desc: like.id)
	\|> Pagination.fetch_paginated(
	Map.merge(params, %{"skip_order" => true}),
	pagination,
	:object_activity
	)
	end

	defp maybe_update_cc(activities, list_memberships, %User{ap_id: user_ap_id})
	when is_list(list_memberships) and length(list_memberships) > 0 do
	Enum.map(activities, fn
	%{data: %{"bcc" => bcc}} = activity when is_list(bcc) and length(bcc) > 0 ->
	if Enum.any?(bcc, &(&1 in list_memberships)) do
	update_in(activity.data["cc"], &[user_ap_id \| &1])
	else
	activity
	end

	activity ->
	activity
	end)
	end

	defp maybe_update_cc(activities, _, _), do: activities

	def fetch_activities_bounded_query(query, recipients, recipients_with_public) do
	from(activity in query,
	where:
	fragment("? && ?", activity.recipients, ^recipients) or
	(fragment("? && ?", activity.recipients, ^recipients_with_public) and
	^Constants.as_public() in activity.recipients)
	)
	end

	def fetch_activities_bounded(
	recipients,
	recipients_with_public,
	opts \\ %{},
	pagination \\ :keyset
	) do
	fetch_activities_query([], opts)
	\|> fetch_activities_bounded_query(recipients, recipients_with_public)
	\|> Pagination.fetch_paginated(opts, pagination)
	\|> Enum.reverse()
	end

	@spec upload(Upload.source(), keyword()) :: {:ok, Object.t()} \| {:error, any()}
	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data =
	if opts[:actor] do
	Map.put(data, "actor", opts[:actor])
	else
	data
	end

	Repo.insert(%Object{data: obj_data})
	end
	end

	@spec get_actor_url(any()) :: binary() \| nil
	defp get_actor_url(url) when is_binary(url), do: url
	defp get_actor_url(%{"href" => href}) when is_binary(href), do: href

	defp get_actor_url(url) when is_list(url) do
	url
	\|> List.first()
	\|> get_actor_url()
	end

	defp get_actor_url(_url), do: nil

	defp object_to_user_data(data) do
	avatar =
	data["icon"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["icon"]["url"]}]
	}

	banner =
	data["image"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["image"]["url"]}]
	}

	fields =
	data
	\|> Map.get("attachment", [])
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)

	emojis =
	data
	\|> Map.get("tag", [])
	\|> Enum.filter(fn
	%{"type" => "Emoji"} -> true
	_ -> false
	end)
	\|> Enum.reduce(%{}, fn %{"icon" => %{"url" => url}, "name" => name}, acc ->
	Map.put(acc, String.trim(name, ":"), url)
	end)

	locked = data["manuallyApprovesFollowers"] \|\| false
	data = Transmogrifier.maybe_fix_user_object(data)
	discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

	public_key =
	if is_map(data["publicKey"]) && is_binary(data["publicKey"]["publicKeyPem"]) do
	data["publicKey"]["publicKeyPem"]
	else
	nil
	end

	shared_inbox =
	if is_map(data["endpoints"]) && is_binary(data["endpoints"]["sharedInbox"]) do
	data["endpoints"]["sharedInbox"]
	else
	nil
	end

	user_data = %{
	ap_id: data["id"],
	uri: get_actor_url(data["url"]),
	ap_enabled: true,
	banner: banner,
	fields: fields,
	emoji: emojis,
	locked: locked,
	discoverable: discoverable,
	invisible: invisible,
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	bio: data["summary"],
	actor_type: actor_type,
	also_known_as: Map.get(data, "alsoKnownAs", []),
	public_key: public_key,
	inbox: data["inbox"],
	shared_inbox: shared_inbox
	}

	# nickname can be nil because of virtual actors
	user_data =
	if data["preferredUsername"] do
	Map.put(
	user_data,
	:nickname,
	"#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
	)
	else
	Map.put(user_data, :nickname, nil)
	end

	{:ok, user_data}
	end

	def fetch_follow_information_for_user(user) do
	with {:ok, following_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.following_address),
	{:ok, hide_follows} <- collection_private(following_data),
	{:ok, followers_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
	{:ok, hide_followers} <- collection_private(followers_data) do
	{:ok,
	%{
	hide_follows: hide_follows,
	follower_count: normalize_counter(followers_data["totalItems"]),
	following_count: normalize_counter(following_data["totalItems"]),
	hide_followers: hide_followers
	}}
	else
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp normalize_counter(counter) when is_integer(counter), do: counter
	defp normalize_counter(_), do: 0

	def maybe_update_follow_information(user_data) do
	with {:enabled, true} <- {:enabled, Config.get([:instance, :external_user_synchronization])},
	{_, true} <- {:user_type_check, user_data[:type] in ["Person", "Service"]},
	{_, true} <-
	{:collections_available,
	!!(user_data[:following_address] && user_data[:follower_address])},
	{:ok, info} <-
	fetch_follow_information_for_user(user_data) do
	info = Map.merge(user_data[:info] \|\| %{}, info)

	user_data
	\|> Map.put(:info, info)
	else
	{:user_type_check, false} ->
	user_data

	{:collections_available, false} ->
	user_data

	{:enabled, false} ->
	user_data

	e ->
	Logger.error(
	"Follower/Following counter update for #{user_data.ap_id} failed.\n" <> inspect(e)
	)

	user_data
	end
	end

	defp collection_private(%{"first" => %{"type" => type}})
	when type in ["CollectionPage", "OrderedCollectionPage"],
	do: {:ok, false}

	defp collection_private(%{"first" => first}) do
	with {:ok, %{"type" => type}} when type in ["CollectionPage", "OrderedCollectionPage"] <-
	Fetcher.fetch_and_contain_remote_object_from_id(first) do
	{:ok, false}
	else
	{:error, {:ok, %{status: code}}} when code in [401, 403] -> {:ok, true}
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

	defp collection_private(_data), do: {:ok, true}

	def user_data_from_user_object(data) do
	with {:ok, data} <- MRF.filter(data),
	{:ok, data} <- object_to_user_data(data) do
	{:ok, data}
	else
	e -> {:error, e}
	end
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data),
	data <- maybe_update_follow_information(data) do
	{:ok, data}
	else
	{:error, "Object has been deleted"} = e ->
	Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}

	e ->
	Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}
	end
	end

	def make_user_from_ap_id(ap_id) do
	user = User.get_cached_by_ap_id(ap_id)

	if user && !User.ap_enabled?(user) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	if user do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	else
	data
	\|> User.remote_user_changeset()
	\|> Repo.insert()
	\|> User.set_cache()
	end
	else
	e -> {:error, e}
	end
	end
	end

	def make_user_from_nickname(nickname) do
	with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
	make_user_from_ap_id(ap_id)
	else
	_e -> {:error, "No AP id in WebFinger"}
	end
	end

	# filter out broken threads
	def contain_broken_threads(%Activity{} = activity, %User{} = user) do
	entire_thread_visible_for_user?(activity, user)
	end

	# do post-processing on a specific activity
	def contain_activity(%Activity{} = activity, %User{} = user) do
	contain_broken_threads(activity, user)
	end

	def fetch_direct_messages_query do
	Activity
	\|> restrict_type(%{"type" => "Create"})
	\|> restrict_visibility(%{visibility: "direct"})
	\|> order_by([activity], asc: activity.id)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub_controller.ex b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	index 62ad15d85..28727d619 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	@@ -1,542 +1,543 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Delivery
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.Plugs.EnsureAuthenticatedPlug
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	+ alias Pleroma.Web.Endpoint
	alias Pleroma.Web.FederatingPlug
	alias Pleroma.Web.Federator

	require Logger

	action_fallback(:errors)

	@federating_only_actions [:internal_fetch, :relay, :relay_following, :relay_followers]

	plug(FederatingPlug when action in @federating_only_actions)

	plug(
	EnsureAuthenticatedPlug,
	[unless_func: &FederatingPlug.federating?/1] when action not in @federating_only_actions
	)

	# Note: :following and :followers must be served even without authentication (as via :api)
	plug(
	EnsureAuthenticatedPlug
	when action in [:read_inbox, :update_outbox, :whoami, :upload_media]
	)

	plug(
	Pleroma.Plugs.Cache,
	[query_params: false, tracking_fun: &__MODULE__.track_object_fetch/2]
	when action in [:activity, :object]
	)

	plug(:set_requester_reachable when action in [:inbox])
	plug(:relay_active? when action in [:relay])

	defp relay_active?(conn, _) do
	if Pleroma.Config.get([:instance, :allow_relay]) do
	conn
	else
	conn
	\|> render_error(:not_found, "not found")
	\|> halt()
	end
	end

	def user(conn, %{"nickname" => nickname}) do
	with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	else
	nil -> {:error, :not_found}
	%{local: false} -> {:error, :not_found}
	end
	end

	- def object(conn, %{"uuid" => uuid}) do
	- with ap_id <- o_status_url(conn, :object, uuid),
	+ def object(conn, _) do
	+ with ap_id <- Endpoint.url() <> conn.request_path,
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(object)} do
	conn
	\|> assign(:tracking_fun_data, object.id)
	\|> set_cache_ttl_for(object)
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(ObjectView)
	\|> render("object.json", object: object)
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def track_object_fetch(conn, nil), do: conn

	def track_object_fetch(conn, object_id) do
	with %{assigns: %{user: %User{id: user_id}}} <- conn do
	Delivery.create(object_id, user_id)
	end

	conn
	end

	- def activity(conn, %{"uuid" => uuid}) do
	- with ap_id <- o_status_url(conn, :activity, uuid),
	+ def activity(conn, _params) do
	+ with ap_id <- Endpoint.url() <> conn.request_path,
	%Activity{} = activity <- Activity.normalize(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(activity)} do
	conn
	\|> maybe_set_tracking_data(activity)
	\|> set_cache_ttl_for(activity)
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(ObjectView)
	\|> render("object.json", object: activity)
	else
	{:public?, false} -> {:error, :not_found}
	nil -> {:error, :not_found}
	end
	end

	defp maybe_set_tracking_data(conn, %Activity{data: %{"type" => "Create"}} = activity) do
	object_id = Object.normalize(activity).id
	assign(conn, :tracking_fun_data, object_id)
	end

	defp maybe_set_tracking_data(conn, _activity), do: conn

	defp set_cache_ttl_for(conn, %Activity{object: object}) do
	set_cache_ttl_for(conn, object)
	end

	defp set_cache_ttl_for(conn, entity) do
	ttl =
	case entity do
	%Object{data: %{"type" => "Question"}} ->
	Pleroma.Config.get([:web_cache_ttl, :activity_pub_question])

	%Object{} ->
	Pleroma.Config.get([:web_cache_ttl, :activity_pub])

	_ ->
	nil
	end

	assign(conn, :cache_ttl, ttl)
	end

	# GET /relay/following
	def relay_following(conn, _params) do
	with %{halted: false} = conn <- FederatingPlug.call(conn, []) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: Relay.get_actor()})
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user),
	{:show_follows, true} <-
	{:show_follows, (for_user && for_user == user) \|\| !user.hide_follows} do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: user, page: page, for: for_user})
	else
	{:show_follows, _} ->
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> send_resp(403, "")
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("following.json", %{user: user, for: for_user})
	end
	end

	# GET /relay/followers
	def relay_followers(conn, _params) do
	with %{halted: false} = conn <- FederatingPlug.call(conn, []) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: Relay.get_actor()})
	end
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user),
	{:show_followers, true} <-
	{:show_followers, (for_user && for_user == user) \|\| !user.hide_followers} do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: user, page: page, for: for_user})
	else
	{:show_followers, _} ->
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> send_resp(403, "")
	end
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{user, for_user} <- ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("followers.json", %{user: user, for: for_user})
	end
	end

	def outbox(
	%{assigns: %{user: for_user}} = conn,
	%{"nickname" => nickname, "page" => page?} = params
	)
	when page? in [true, "true"] do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- User.ensure_keys_present(user) do
	activities =
	if params["max_id"] do
	ActivityPub.fetch_user_activities(user, for_user, %{
	"max_id" => params["max_id"],
	# This is a hack because postgres generates inefficient queries when filtering by
	# 'Answer', poll votes will be hidden by the visibility filter in this case anyway
	"include_poll_votes" => true,
	"limit" => 10
	})
	else
	ActivityPub.fetch_user_activities(user, for_user, %{
	"limit" => 10,
	"include_poll_votes" => true
	})
	end

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection_page.json", %{
	activities: activities,
	iri: "#{user.ap_id}/outbox"
	})
	end
	end

	def outbox(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection.json", %{iri: "#{user.ap_id}/outbox"})
	end
	end

	def inbox(%{assigns: %{valid_signature: true}} = conn, %{"nickname" => nickname} = params) do
	with %User{} = recipient <- User.get_cached_by_nickname(nickname),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(params["actor"]),
	true <- Utils.recipient_in_message(recipient, actor, params),
	params <- Utils.maybe_splice_recipient(recipient.ap_id, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end
	end

	def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end

	# POST /relay/inbox -or- POST /internal/fetch/inbox
	def inbox(conn, params) do
	if params["type"] == "Create" && FederatingPlug.federating?() do
	post_inbox_relayed_create(conn, params)
	else
	post_inbox_fallback(conn, params)
	end
	end

	defp post_inbox_relayed_create(conn, params) do
	Logger.debug(
	"Signature missing or not from author, relayed Create message, fetching object from source"
	)

	Fetcher.fetch_object_from_id(params["object"]["id"])

	json(conn, "ok")
	end

	defp post_inbox_fallback(conn, params) do
	headers = Enum.into(conn.req_headers, %{})

	if headers["signature"] && params["actor"] &&
	String.contains?(headers["signature"], params["actor"]) do
	Logger.debug(
	"Signature validation error for: #{params["actor"]}, make sure you are forwarding the HTTP Host header!"
	)

	Logger.debug(inspect(conn.req_headers))
	end

	conn
	\|> put_status(:bad_request)
	\|> json(dgettext("errors", "error"))
	end

	defp represent_service_actor(%User{} = user, conn) do
	with {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	else
	nil -> {:error, :not_found}
	end
	end

	defp represent_service_actor(nil, _), do: {:error, :not_found}

	def relay(conn, _params) do
	Relay.get_actor()
	\|> represent_service_actor(conn)
	end

	def internal_fetch(conn, _params) do
	InternalFetchActor.get_actor()
	\|> represent_service_actor(conn)
	end

	@doc "Returns the authenticated user's ActivityPub User object or a 404 Not Found if non-authenticated"
	def whoami(%{assigns: %{user: %User{} = user}} = conn, _params) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("user.json", %{user: user})
	end

	def read_inbox(
	%{assigns: %{user: %User{nickname: nickname} = user}} = conn,
	%{"nickname" => nickname, "page" => page?} = params
	)
	when page? in [true, "true"] do
	activities =
	if params["max_id"] do
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], %{
	"max_id" => params["max_id"],
	"limit" => 10
	})
	else
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], %{"limit" => 10})
	end

	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection_page.json", %{
	activities: activities,
	iri: "#{user.ap_id}/inbox"
	})
	end

	def read_inbox(%{assigns: %{user: %User{nickname: nickname} = user}} = conn, %{
	"nickname" => nickname
	}) do
	with {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_content_type("application/activity+json")
	\|> put_view(UserView)
	\|> render("activity_collection.json", %{iri: "#{user.ap_id}/inbox"})
	end
	end

	def read_inbox(%{assigns: %{user: %User{nickname: as_nickname}}} = conn, %{
	"nickname" => nickname
	}) do
	err =
	dgettext("errors", "can't read inbox of %{nickname} as %{as_nickname}",
	nickname: nickname,
	as_nickname: as_nickname
	)

	conn
	\|> put_status(:forbidden)
	\|> json(err)
	end

	defp handle_user_activity(
	%User{} = user,
	%{"type" => "Create", "object" => %{"type" => "Note"}} = params
	) do
	object =
	params["object"]
	\|> Map.merge(Map.take(params, ["to", "cc"]))
	\|> Map.put("attributedTo", user.ap_id())
	\|> Transmogrifier.fix_object()

	ActivityPub.create(%{
	to: params["to"],
	actor: user,
	context: object["context"],
	object: object,
	additional: Map.take(params, ["cc"])
	})
	end

	defp handle_user_activity(%User{} = user, %{"type" => "Delete"} = params) do
	with %Object{} = object <- Object.normalize(params["object"]),
	true <- user.is_moderator \|\| user.ap_id == object.data["actor"],
	{:ok, delete_data, _} <- Builder.delete(user, object.data["id"]),
	{:ok, delete, _} <- Pipeline.common_pipeline(delete_data, local: true) do
	{:ok, delete}
	else
	_ -> {:error, dgettext("errors", "Can't delete object")}
	end
	end

	defp handle_user_activity(%User{} = user, %{"type" => "Like"} = params) do
	with %Object{} = object <- Object.normalize(params["object"]),
	{_, {:ok, like_object, meta}} <- {:build_object, Builder.like(user, object)},
	{_, {:ok, %Activity{} = activity, _meta}} <-
	{:common_pipeline,
	Pipeline.common_pipeline(like_object, Keyword.put(meta, :local, true))} do
	{:ok, activity}
	else
	_ -> {:error, dgettext("errors", "Can't like object")}
	end
	end

	defp handle_user_activity(_, _) do
	{:error, dgettext("errors", "Unhandled activity type")}
	end

	def update_outbox(
	%{assigns: %{user: %User{nickname: nickname} = user}} = conn,
	%{"nickname" => nickname} = params
	) do
	actor = user.ap_id()

	params =
	params
	\|> Map.drop(["id"])
	\|> Map.put("actor", actor)
	\|> Transmogrifier.fix_addressing()

	with {:ok, %Activity{} = activity} <- handle_user_activity(user, params) do
	conn
	\|> put_status(:created)
	\|> put_resp_header("location", activity.data["id"])
	\|> json(activity.data)
	else
	{:error, message} ->
	conn
	\|> put_status(:bad_request)
	\|> json(message)
	end
	end

	def update_outbox(%{assigns: %{user: %User{} = user}} = conn, %{"nickname" => nickname}) do
	err =
	dgettext("errors", "can't update outbox of %{nickname} as %{as_nickname}",
	nickname: nickname,
	as_nickname: user.nickname
	)

	conn
	\|> put_status(:forbidden)
	\|> json(err)
	end

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

	defp errors(conn, _e) do
	conn
	\|> put_status(:internal_server_error)
	\|> json(dgettext("errors", "error"))
	end

	defp set_requester_reachable(%Plug.Conn{} = conn, _) do
	with actor <- conn.params["actor"],
	true <- is_binary(actor) do
	Pleroma.Instances.set_reachable(actor)
	end

	conn
	end

	defp ensure_user_keys_present_and_maybe_refresh_for_user(user, for_user) do
	{:ok, new_user} = User.ensure_keys_present(user)

	for_user =
	if new_user != user and match?(%User{}, for_user) do
	User.get_cached_by_nickname(for_user.nickname)
	else
	for_user
	end

	{new_user, for_user}
	end

	# TODO: Add support for "object" field
	@doc """
	Endpoint based on <https://www.w3.org/wiki/SocialCG/ActivityPub/MediaUpload>

	Parameters:
	- (required) `file`: data of the media
	- (optionnal) `description`: description of the media, intended for accessibility

	Response:
	- HTTP Code: 201 Created
	- HTTP Body: ActivityPub object to be inserted into another's `attachment` field
	"""
	def upload_media(%{assigns: %{user: %User{} = user}} = conn, %{"file" => file} = data) do
	with {:ok, object} <-
	ActivityPub.upload(
	file,
	actor: User.ap_id(user),
	description: Map.get(data, "description")
	) do
	Logger.debug(inspect(object))

	conn
	\|> put_status(:created)
	\|> json(object.data)
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/controllers/admin_api_controller.ex
	similarity index 89%
	rename from lib/pleroma/web/admin_api/admin_api_controller.ex
	rename to lib/pleroma/web/admin_api/controllers/admin_api_controller.ex
	index 647ceb3ba..6b1d64a2e 100644
	--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/admin_api_controller.ex
	@@ -1,1207 +1,1103 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIController do
	use Pleroma.Web, :controller

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

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.ConfigDB
	alias Pleroma.MFA
	alias Pleroma.ModerationLog
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.ReportNote
	alias Pleroma.Stats
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.AdminAPI.ConfigView
	alias Pleroma.Web.AdminAPI.ModerationLogView
	alias Pleroma.Web.AdminAPI.Report
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.AdminAPI.Search
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MastodonAPI
	alias Pleroma.Web.MastodonAPI.AppView
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.Router

	require Logger

	@descriptions Pleroma.Docs.JSON.compile()
	@users_page_size 50

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:accounts"], admin: true}
	when action in [:list_users, :user_show, :right_get, :show_user_credentials]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:accounts"], admin: true}
	when action in [
	:get_password_reset,
	:force_password_reset,
	:user_delete,
	:users_create,
	:user_toggle_activation,
	:user_activate,
	:user_deactivate,
	:tag_users,
	:untag_users,
	:right_add,
	:right_add_multiple,
	:right_delete,
	:disable_mfa,
	:right_delete_multiple,
	:update_user_credentials
	]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:invites"], admin: true} when action == :invites)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:invites"], admin: true}
	when action in [:create_invite_token, :revoke_invite, :email_invite]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:follows"], admin: true}
	when action in [:user_follow, :user_unfollow, :relay_follow, :relay_unfollow]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:reports"], admin: true}
	when action in [:list_reports, :report_show]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:reports"], admin: true}
	when action in [:reports_update, :report_notes_create, :report_notes_delete]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:statuses"], admin: true}
	- when action in [:list_statuses, :list_user_statuses, :list_instance_statuses, :status_show]
	- )
	-
	- plug(
	- OAuthScopesPlug,
	- %{scopes: ["write:statuses"], admin: true}
	- when action in [:status_update, :status_delete]
	+ when action in [:list_user_statuses, :list_instance_statuses]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read"], admin: true}
	when action in [
	:config_show,
	:list_log,
	:stats,
	:relay_list,
	:config_descriptions,
	:need_reboot
	]
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write"], admin: true}
	when action in [
	:restart,
	:config_update,
	:resend_confirmation_email,
	:confirm_email,
	:oauth_app_create,
	:oauth_app_list,
	:oauth_app_update,
	:oauth_app_delete,
	:reload_emoji
	]
	)

	- action_fallback(:errors)
	+ action_fallback(AdminAPI.FallbackController)

	def user_delete(conn, %{"nickname" => nickname}) do
	user_delete(conn, %{"nicknames" => [nickname]})
	end

	def user_delete(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users =
	nicknames
	\|> Enum.map(&User.get_cached_by_nickname/1)

	users
	\|> Enum.each(fn user ->
	{:ok, delete_data, _} = Builder.delete(admin, user.ap_id)
	Pipeline.common_pipeline(delete_data, local: true)
	end)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "delete"
	})

	conn
	\|> json(nicknames)
	end

	def user_follow(%{assigns: %{user: admin}} = 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)

	ModerationLog.insert_log(%{
	actor: admin,
	followed: followed,
	follower: follower,
	action: "follow"
	})
	end

	conn
	\|> json("ok")
	end

	def user_unfollow(%{assigns: %{user: admin}} = 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)

	ModerationLog.insert_log(%{
	actor: admin,
	followed: followed,
	follower: follower,
	action: "unfollow"
	})
	end

	conn
	\|> json("ok")
	end

	def users_create(%{assigns: %{user: admin}} = conn, %{"users" => users}) do
	changesets =
	Enum.map(users, fn %{"nickname" => nickname, "email" => email, "password" => password} ->
	user_data = %{
	nickname: nickname,
	name: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	bio: "."
	}

	User.register_changeset(%User{}, user_data, need_confirmation: false)
	end)
	\|> Enum.reduce(Ecto.Multi.new(), fn changeset, multi ->
	Ecto.Multi.insert(multi, Ecto.UUID.generate(), changeset)
	end)

	case Pleroma.Repo.transaction(changesets) do
	{:ok, users} ->
	res =
	users
	\|> Map.values()
	\|> Enum.map(fn user ->
	{:ok, user} = User.post_register_action(user)

	user
	end)
	\|> Enum.map(&AccountView.render("created.json", %{user: &1}))

	ModerationLog.insert_log(%{
	actor: admin,
	subjects: Map.values(users),
	action: "create"
	})

	conn
	\|> json(res)

	{:error, id, changeset, _} ->
	res =
	Enum.map(changesets.operations, fn
	{current_id, {:changeset, _current_changeset, _}} when current_id == id ->
	AccountView.render("create-error.json", %{changeset: changeset})

	{_, {:changeset, current_changeset, _}} ->
	AccountView.render("create-error.json", %{changeset: current_changeset})
	end)

	conn
	\|> put_status(:conflict)
	\|> json(res)
	end
	end

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

	def list_instance_statuses(conn, %{"instance" => instance} = params) do
	with_reblogs = params["with_reblogs"] == "true" \|\| params["with_reblogs"] == true
	{page, page_size} = page_params(params)

	activities =
	ActivityPub.fetch_statuses(nil, %{
	"instance" => instance,
	"limit" => page_size,
	"offset" => (page - 1) * page_size,
	"exclude_reblogs" => !with_reblogs && "true"
	})

	conn
	\|> put_view(AdminAPI.StatusView)
	\|> render("index.json", %{activities: activities, as: :activity})
	end

	def list_user_statuses(conn, %{"nickname" => nickname} = params) do
	with_reblogs = params["with_reblogs"] == "true" \|\| params["with_reblogs"] == true
	godmode = params["godmode"] == "true" \|\| params["godmode"] == true

	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname) do
	{_, page_size} = page_params(params)

	activities =
	ActivityPub.fetch_user_activities(user, nil, %{
	"limit" => page_size,
	"godmode" => godmode,
	"exclude_reblogs" => !with_reblogs && "true"
	})

	conn
	\|> put_view(MastodonAPI.StatusView)
	\|> render("index.json", %{activities: activities, as: :activity})
	else
	_ -> {:error, :not_found}
	end
	end

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

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

	action = if user.deactivated, do: "activate", else: "deactivate"

	ModerationLog.insert_log(%{
	actor: admin,
	subject: [user],
	action: action
	})

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

	def user_activate(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.deactivate(users, false)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "activate"
	})

	conn
	\|> put_view(AccountView)
	\|> render("index.json", %{users: Keyword.values(updated_users)})
	end

	def user_deactivate(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = Enum.map(nicknames, &User.get_cached_by_nickname/1)
	{:ok, updated_users} = User.deactivate(users, true)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "deactivate"
	})

	conn
	\|> put_view(AccountView)
	\|> render("index.json", %{users: Keyword.values(updated_users)})
	end

	def tag_users(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.tag(nicknames, tags) do
	ModerationLog.insert_log(%{
	actor: admin,
	nicknames: nicknames,
	tags: tags,
	action: "tag"
	})

	json_response(conn, :no_content, "")
	end
	end

	def untag_users(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.untag(nicknames, tags) do
	ModerationLog.insert_log(%{
	actor: admin,
	nicknames: nicknames,
	tags: tags,
	action: "untag"
	})

	json_response(conn, :no_content, "")
	end
	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
	json(
	conn,
	AccountView.render("index.json", users: users, count: count, page_size: page_size)
	)
	end
	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_multiple(%{assigns: %{user: admin}} = conn, %{
	"permission_group" => permission_group,
	"nicknames" => nicknames
	})
	when permission_group in ["moderator", "admin"] do
	update = %{:"is_#{permission_group}" => true}

	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	for u <- users, do: User.admin_api_update(u, update)

	ModerationLog.insert_log(%{
	action: "grant",
	actor: admin,
	subject: users,
	permission: permission_group
	})

	json(conn, update)
	end

	def right_add_multiple(conn, _) do
	render_error(conn, :not_found, "No such permission_group")
	end

	def right_add(%{assigns: %{user: admin}} = conn, %{
	"permission_group" => permission_group,
	"nickname" => nickname
	})
	when permission_group in ["moderator", "admin"] do
	fields = %{:"is_#{permission_group}" => true}

	{:ok, user} =
	nickname
	\|> User.get_cached_by_nickname()
	\|> User.admin_api_update(fields)

	ModerationLog.insert_log(%{
	action: "grant",
	actor: admin,
	subject: [user],
	permission: permission_group
	})

	json(conn, fields)
	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.is_moderator,
	is_admin: user.is_admin
	})
	end

	def right_delete_multiple(
	%{assigns: %{user: %{nickname: admin_nickname} = admin}} = conn,
	%{
	"permission_group" => permission_group,
	"nicknames" => nicknames
	}
	)
	when permission_group in ["moderator", "admin"] do
	with false <- Enum.member?(nicknames, admin_nickname) do
	update = %{:"is_#{permission_group}" => false}

	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	for u <- users, do: User.admin_api_update(u, update)

	ModerationLog.insert_log(%{
	action: "revoke",
	actor: admin,
	subject: users,
	permission: permission_group
	})

	json(conn, update)
	else
	_ -> render_error(conn, :forbidden, "You can't revoke your own admin/moderator status.")
	end
	end

	def right_delete_multiple(conn, _) do
	render_error(conn, :not_found, "No such permission_group")
	end

	def right_delete(
	%{assigns: %{user: admin}} = conn,
	%{
	"permission_group" => permission_group,
	"nickname" => nickname
	}
	)
	when permission_group in ["moderator", "admin"] do
	fields = %{:"is_#{permission_group}" => false}

	{:ok, user} =
	nickname
	\|> User.get_cached_by_nickname()
	\|> User.admin_api_update(fields)

	ModerationLog.insert_log(%{
	action: "revoke",
	actor: admin,
	subject: [user],
	permission: permission_group
	})

	json(conn, fields)
	end

	def right_delete(%{assigns: %{user: %{nickname: nickname}}} = conn, %{"nickname" => nickname}) do
	render_error(conn, :forbidden, "You can't revoke your own admin status.")
	end

	def relay_list(conn, _params) do
	with {:ok, list} <- Relay.list() do
	json(conn, %{relays: list})
	else
	_ ->
	conn
	\|> put_status(500)
	end
	end

	def relay_follow(%{assigns: %{user: admin}} = conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.follow(target) do
	ModerationLog.insert_log(%{
	action: "relay_follow",
	actor: admin,
	target: target
	})

	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	def relay_unfollow(%{assigns: %{user: admin}} = conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.unfollow(target) do
	ModerationLog.insert_log(%{
	action: "relay_unfollow",
	actor: admin,
	target: target
	})

	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 {_, false} <- {:registrations_open, Config.get([:instance, :registrations_open])},
	{_, true} <- {:invites_enabled, Config.get([:instance, :invites_enabled])},
	{: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, "")
	else
	{:registrations_open, _} ->
	- errors(
	- conn,
	- {:error, "To send invites you need to set the `registrations_open` option to false."}
	- )
	+ {:error, "To send invites you need to set the `registrations_open` option to false."}

	{:invites_enabled, _} ->
	- errors(
	- conn,
	- {:error, "To send invites you need to set the `invites_enabled` option to true."}
	- )
	+ {:error, "To send invites you need to set the `invites_enabled` option to true."}
	end
	end

	@doc "Create an account registration invite token"
	def create_invite_token(conn, params) do
	opts = %{}

	opts =
	if params["max_use"],
	do: Map.put(opts, :max_use, params["max_use"]),
	else: opts

	opts =
	if params["expires_at"],
	do: Map.put(opts, :expires_at, params["expires_at"]),
	else: opts

	{:ok, invite} = UserInviteToken.create_invite(opts)

	json(conn, AccountView.render("invite.json", %{invite: invite}))
	end

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

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

	@doc "Revokes invite by token"
	def revoke_invite(conn, %{"token" => token}) do
	with {:ok, invite} <- UserInviteToken.find_by_token(token),
	{:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true}) do
	conn
	\|> put_view(AccountView)
	\|> render("invite.json", %{invite: updated_invite})
	else
	nil -> {:error, :not_found}
	end
	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.token,
	link: Router.Helpers.reset_password_url(Endpoint, :reset, token.token)
	})
	end

	@doc "Force password reset for a given user"
	def force_password_reset(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	Enum.each(users, &User.force_password_reset_async/1)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "force_password_reset"
	})

	json_response(conn, :no_content, "")
	end

	@doc "Disable mfa for user's account."
	def disable_mfa(conn, %{"nickname" => nickname}) do
	case User.get_by_nickname(nickname) do
	%User{} = user ->
	MFA.disable(user)
	json(conn, nickname)

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

	@doc "Show a given user's credentials"
	def show_user_credentials(%{assigns: %{user: admin}} = conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname) do
	conn
	\|> put_view(AccountView)
	\|> render("credentials.json", %{user: user, for: admin})
	else
	_ -> {:error, :not_found}
	end
	end

	@doc "Updates a given user"
	def update_user_credentials(
	%{assigns: %{user: admin}} = conn,
	%{"nickname" => nickname} = params
	) do
	with {_, user} <- {:user, User.get_cached_by_nickname(nickname)},
	{:ok, _user} <-
	User.update_as_admin(user, params) do
	ModerationLog.insert_log(%{
	actor: admin,
	subject: [user],
	action: "updated_users"
	})

	if params["password"] do
	User.force_password_reset_async(user)
	end

	ModerationLog.insert_log(%{
	actor: admin,
	subject: [user],
	action: "force_password_reset"
	})

	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "New password #{error}."})

	_ ->
	json(conn, %{error: "Unable to change password."})
	end
	end

	def list_reports(conn, params) do
	{page, page_size} = page_params(params)

	reports = Utils.get_reports(params, page, page_size)

	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.extract_report_info(report))
	else
	_ -> {:error, :not_found}
	end
	end

	def reports_update(%{assigns: %{user: admin}} = conn, %{"reports" => reports}) do
	result =
	reports
	\|> Enum.map(fn report ->
	with {:ok, activity} <- CommonAPI.update_report_state(report["id"], report["state"]) do
	ModerationLog.insert_log(%{
	action: "report_update",
	actor: admin,
	subject: activity
	})

	activity
	else
	{:error, message} -> %{id: report["id"], error: message}
	end
	end)

	case Enum.any?(result, &Map.has_key?(&1, :error)) do
	true -> json_response(conn, :bad_request, result)
	false -> json_response(conn, :no_content, "")
	end
	end

	def report_notes_create(%{assigns: %{user: user}} = conn, %{
	"id" => report_id,
	"content" => content
	}) do
	with {:ok, _} <- ReportNote.create(user.id, report_id, content) do
	ModerationLog.insert_log(%{
	action: "report_note",
	actor: user,
	subject: Activity.get_by_id(report_id),
	text: content
	})

	json_response(conn, :no_content, "")
	else
	_ -> json_response(conn, :bad_request, "")
	end
	end

	def report_notes_delete(%{assigns: %{user: user}} = conn, %{
	"id" => note_id,
	"report_id" => report_id
	}) do
	with {:ok, note} <- ReportNote.destroy(note_id) do
	ModerationLog.insert_log(%{
	action: "report_note_delete",
	actor: user,
	subject: Activity.get_by_id(report_id),
	text: note.content
	})

	json_response(conn, :no_content, "")
	else
	_ -> json_response(conn, :bad_request, "")
	end
	end

	- def list_statuses(%{assigns: %{user: _admin}} = conn, params) do
	- godmode = params["godmode"] == "true" \|\| params["godmode"] == true
	- local_only = params["local_only"] == "true" \|\| params["local_only"] == true
	- with_reblogs = params["with_reblogs"] == "true" \|\| params["with_reblogs"] == true
	- {page, page_size} = page_params(params)
	-
	- activities =
	- ActivityPub.fetch_statuses(nil, %{
	- "godmode" => godmode,
	- "local_only" => local_only,
	- "limit" => page_size,
	- "offset" => (page - 1) * page_size,
	- "exclude_reblogs" => !with_reblogs && "true"
	- })
	-
	- conn
	- \|> put_view(AdminAPI.StatusView)
	- \|> render("index.json", %{activities: activities, as: :activity})
	- end
	-
	- def status_show(conn, %{"id" => id}) do
	- with %Activity{} = activity <- Activity.get_by_id(id) do
	- conn
	- \|> put_view(MastodonAPI.StatusView)
	- \|> render("show.json", %{activity: activity})
	- else
	- _ -> errors(conn, {:error, :not_found})
	- end
	- end
	-
	- def status_update(%{assigns: %{user: admin}} = conn, %{"id" => id} = params) do
	- params =
	- params
	- \|> Map.take(["sensitive", "visibility"])
	- \|> Map.new(fn {key, value} -> {String.to_existing_atom(key), value} end)
	-
	- with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do
	- {:ok, sensitive} = Ecto.Type.cast(:boolean, params[:sensitive])
	-
	- ModerationLog.insert_log(%{
	- action: "status_update",
	- actor: admin,
	- subject: activity,
	- sensitive: sensitive,
	- visibility: params[:visibility]
	- })
	-
	- conn
	- \|> put_view(MastodonAPI.StatusView)
	- \|> render("show.json", %{activity: activity})
	- end
	- end
	-
	- def status_delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	- with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	- ModerationLog.insert_log(%{
	- action: "status_delete",
	- actor: user,
	- subject_id: id
	- })
	-
	- json(conn, %{})
	- end
	- end
	-
	def list_log(conn, params) do
	{page, page_size} = page_params(params)

	log =
	ModerationLog.get_all(%{
	page: page,
	page_size: page_size,
	start_date: params["start_date"],
	end_date: params["end_date"],
	user_id: params["user_id"],
	search: params["search"]
	})

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

	def config_descriptions(conn, _params) do
	descriptions = Enum.filter(@descriptions, &whitelisted_config?/1)

	json(conn, descriptions)
	end

	def config_show(conn, %{"only_db" => true}) do
	- with :ok <- configurable_from_database(conn) do
	+ with :ok <- configurable_from_database() do
	configs = Pleroma.Repo.all(ConfigDB)

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

	def config_show(conn, _params) do
	- with :ok <- configurable_from_database(conn) do
	+ with :ok <- configurable_from_database() do
	configs = ConfigDB.get_all_as_keyword()

	merged =
	Config.Holder.default_config()
	\|> ConfigDB.merge(configs)
	\|> Enum.map(fn {group, values} ->
	Enum.map(values, fn {key, value} ->
	db =
	if configs[group][key] do
	ConfigDB.get_db_keys(configs[group][key], key)
	end

	db_value = configs[group][key]

	merged_value =
	if !is_nil(db_value) and Keyword.keyword?(db_value) and
	ConfigDB.sub_key_full_update?(group, key, Keyword.keys(db_value)) do
	ConfigDB.merge_group(group, key, value, db_value)
	else
	value
	end

	setting = %{
	group: ConfigDB.convert(group),
	key: ConfigDB.convert(key),
	value: ConfigDB.convert(merged_value)
	}

	if db, do: Map.put(setting, :db, db), else: setting
	end)
	end)
	\|> List.flatten()

	json(conn, %{configs: merged, need_reboot: Restarter.Pleroma.need_reboot?()})
	end
	end

	def config_update(conn, %{"configs" => configs}) do
	- with :ok <- configurable_from_database(conn) do
	+ with :ok <- configurable_from_database() do
	{_errors, results} =
	configs
	\|> Enum.filter(&whitelisted_config?/1)
	\|> Enum.map(fn
	%{"group" => group, "key" => key, "delete" => true} = params ->
	ConfigDB.delete(%{group: group, key: key, subkeys: params["subkeys"]})

	%{"group" => group, "key" => key, "value" => value} ->
	ConfigDB.update_or_create(%{group: group, key: key, value: value})
	end)
	\|> Enum.split_with(fn result -> elem(result, 0) == :error end)

	{deleted, updated} =
	results
	\|> Enum.map(fn {:ok, config} ->
	Map.put(config, :db, ConfigDB.get_db_keys(config))
	end)
	\|> Enum.split_with(fn config ->
	Ecto.get_meta(config, :state) == :deleted
	end)

	Config.TransferTask.load_and_update_env(deleted, false)

	if !Restarter.Pleroma.need_reboot?() do
	changed_reboot_settings? =
	(updated ++ deleted)
	\|> Enum.any?(fn config ->
	group = ConfigDB.from_string(config.group)
	key = ConfigDB.from_string(config.key)
	value = ConfigDB.from_binary(config.value)
	Config.TransferTask.pleroma_need_restart?(group, key, value)
	end)

	if changed_reboot_settings?, do: Restarter.Pleroma.need_reboot()
	end

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

	def restart(conn, _params) do
	- with :ok <- configurable_from_database(conn) do
	+ with :ok <- configurable_from_database() do
	Restarter.Pleroma.restart(Config.get(:env), 50)

	json(conn, %{})
	end
	end

	def need_reboot(conn, _params) do
	json(conn, %{need_reboot: Restarter.Pleroma.need_reboot?()})
	end

	- defp configurable_from_database(conn) do
	+ defp configurable_from_database do
	if Config.get(:configurable_from_database) do
	:ok
	else
	- errors(
	- conn,
	- {:error, "To use this endpoint you need to enable configuration from database."}
	- )
	+ {:error, "To use this endpoint you need to enable configuration from database."}
	end
	end

	defp whitelisted_config?(group, key) do
	if whitelisted_configs = Config.get(:database_config_whitelist) do
	Enum.any?(whitelisted_configs, fn
	{whitelisted_group} ->
	group == inspect(whitelisted_group)

	{whitelisted_group, whitelisted_key} ->
	group == inspect(whitelisted_group) && key == inspect(whitelisted_key)
	end)
	else
	true
	end
	end

	defp whitelisted_config?(%{"group" => group, "key" => key}) do
	whitelisted_config?(group, key)
	end

	defp whitelisted_config?(%{:group => group} = config) do
	whitelisted_config?(group, config[:key])
	end

	def reload_emoji(conn, _params) do
	Pleroma.Emoji.reload()

	conn \|> json("ok")
	end

	def confirm_email(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	User.toggle_confirmation(users)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "confirm_email"
	})

	conn \|> json("")
	end

	def resend_confirmation_email(%{assigns: %{user: admin}} = conn, %{"nicknames" => nicknames}) do
	users = nicknames \|> Enum.map(&User.get_cached_by_nickname/1)

	User.try_send_confirmation_email(users)

	ModerationLog.insert_log(%{
	actor: admin,
	subject: users,
	action: "resend_confirmation_email"
	})

	conn \|> json("")
	end

	def oauth_app_create(conn, params) do
	params =
	if params["name"] do
	Map.put(params, "client_name", params["name"])
	else
	params
	end

	result =
	case App.create(params) do
	{:ok, app} ->
	AppView.render("show.json", %{app: app, admin: true})

	{:error, changeset} ->
	App.errors(changeset)
	end

	json(conn, result)
	end

	def oauth_app_update(conn, params) do
	params =
	if params["name"] do
	Map.put(params, "client_name", params["name"])
	else
	params
	end

	with {:ok, app} <- App.update(params) do
	json(conn, AppView.render("show.json", %{app: app, admin: true}))
	else
	{:error, changeset} ->
	json(conn, App.errors(changeset))

	nil ->
	json_response(conn, :bad_request, "")
	end
	end

	def oauth_app_list(conn, params) do
	{page, page_size} = page_params(params)

	search_params = %{
	client_name: params["name"],
	client_id: params["client_id"],
	page: page,
	page_size: page_size
	}

	search_params =
	if Map.has_key?(params, "trusted") do
	Map.put(search_params, :trusted, params["trusted"])
	else
	search_params
	end

	with {:ok, apps, count} <- App.search(search_params) do
	json(
	conn,
	AppView.render("index.json",
	apps: apps,
	count: count,
	page_size: page_size,
	admin: true
	)
	)
	end
	end

	def oauth_app_delete(conn, params) do
	with {:ok, _app} <- App.destroy(params["id"]) do
	json_response(conn, :no_content, "")
	else
	_ -> json_response(conn, :bad_request, "")
	end
	end

	def stats(conn, _) do
	count = Stats.get_status_visibility_count()

	conn
	\|> json(%{"status_visibility" => count})
	end

	- defp errors(conn, {:error, :not_found}) do
	- conn
	- \|> put_status(:not_found)
	- \|> json(dgettext("errors", "Not found"))
	- end
	-
	- defp errors(conn, {:error, reason}) do
	- conn
	- \|> put_status(:bad_request)
	- \|> json(reason)
	- end
	-
	- defp errors(conn, {:param_cast, _}) do
	- conn
	- \|> put_status(:bad_request)
	- \|> json(dgettext("errors", "Invalid parameters"))
	- end
	-
	- defp 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/controllers/fallback_controller.ex b/lib/pleroma/web/admin_api/controllers/fallback_controller.ex
	new file mode 100644
	index 000000000..82965936d
	--- /dev/null
	+++ b/lib/pleroma/web/admin_api/controllers/fallback_controller.ex
	@@ -0,0 +1,31 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.AdminAPI.FallbackController do
	+ use Pleroma.Web, :controller
	+
	+ def call(conn, {:error, :not_found}) do
	+ conn
	+ \|> put_status(:not_found)
	+ \|> json(%{error: dgettext("errors", "Not found")})
	+ end
	+
	+ def call(conn, {:error, reason}) do
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(%{error: reason})
	+ end
	+
	+ def call(conn, {:param_cast, _}) do
	+ conn
	+ \|> put_status(:bad_request)
	+ \|> json(dgettext("errors", "Invalid parameters"))
	+ end
	+
	+ def call(conn, _) do
	+ conn
	+ \|> put_status(:internal_server_error)
	+ \|> json(%{error: dgettext("errors", "Something went wrong")})
	+ end
	+end
	diff --git a/lib/pleroma/web/admin_api/controllers/status_controller.ex b/lib/pleroma/web/admin_api/controllers/status_controller.ex
	new file mode 100644
	index 000000000..08cb9c10b
	--- /dev/null
	+++ b/lib/pleroma/web/admin_api/controllers/status_controller.ex
	@@ -0,0 +1,79 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.AdminAPI.StatusController do
	+ use Pleroma.Web, :controller
	+
	+ alias Pleroma.Activity
	+ alias Pleroma.ModerationLog
	+ alias Pleroma.Plugs.OAuthScopesPlug
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.CommonAPI
	+ alias Pleroma.Web.MastodonAPI
	+
	+ require Logger
	+
	+ plug(Pleroma.Web.ApiSpec.CastAndValidate)
	+ plug(OAuthScopesPlug, %{scopes: ["read:statuses"], admin: true} when action in [:index, :show])
	+
	+ plug(
	+ OAuthScopesPlug,
	+ %{scopes: ["write:statuses"], admin: true} when action in [:update, :delete]
	+ )
	+
	+ action_fallback(Pleroma.Web.AdminAPI.FallbackController)
	+
	+ defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.Admin.StatusOperation
	+
	+ def index(%{assigns: %{user: _admin}} = conn, params) do
	+ activities =
	+ ActivityPub.fetch_statuses(nil, %{
	+ "godmode" => params.godmode,
	+ "local_only" => params.local_only,
	+ "limit" => params.page_size,
	+ "offset" => (params.page - 1) * params.page_size,
	+ "exclude_reblogs" => not params.with_reblogs
	+ })
	+
	+ render(conn, "index.json", activities: activities, as: :activity)
	+ end
	+
	+ def show(conn, %{id: id}) do
	+ with %Activity{} = activity <- Activity.get_by_id(id) do
	+ conn
	+ \|> put_view(MastodonAPI.StatusView)
	+ \|> render("show.json", %{activity: activity})
	+ else
	+ nil -> {:error, :not_found}
	+ end
	+ end
	+
	+ def update(%{assigns: %{user: admin}, body_params: params} = conn, %{id: id}) do
	+ with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do
	+ ModerationLog.insert_log(%{
	+ action: "status_update",
	+ actor: admin,
	+ subject: activity,
	+ sensitive: params[:sensitive],
	+ visibility: params[:visibility]
	+ })
	+
	+ conn
	+ \|> put_view(MastodonAPI.StatusView)
	+ \|> render("show.json", %{activity: activity})
	+ end
	+ end
	+
	+ def delete(%{assigns: %{user: user}} = conn, %{id: id}) do
	+ with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	+ ModerationLog.insert_log(%{
	+ action: "status_delete",
	+ actor: user,
	+ subject_id: id
	+ })
	+
	+ json(conn, %{})
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/status_operation.ex b/lib/pleroma/web/api_spec/operations/admin/status_operation.ex
	new file mode 100644
	index 000000000..0b138dc79
	--- /dev/null
	+++ b/lib/pleroma/web/api_spec/operations/admin/status_operation.ex
	@@ -0,0 +1,165 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ApiSpec.Admin.StatusOperation do
	+ alias OpenApiSpex.Operation
	+ alias OpenApiSpex.Schema
	+ alias Pleroma.Web.ApiSpec.Schemas.Account
	+ alias Pleroma.Web.ApiSpec.Schemas.ApiError
	+ alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	+ alias Pleroma.Web.ApiSpec.Schemas.Status
	+ alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope
	+
	+ import Pleroma.Web.ApiSpec.Helpers
	+ import Pleroma.Web.ApiSpec.StatusOperation, only: [id_param: 0]
	+
	+ def open_api_operation(action) do
	+ operation = String.to_existing_atom("#{action}_operation")
	+ apply(__MODULE__, operation, [])
	+ end
	+
	+ def index_operation do
	+ %Operation{
	+ tags: ["Admin", "Statuses"],
	+ operationId: "AdminAPI.StatusController.index",
	+ security: [%{"oAuth" => ["read:statuses"]}],
	+ parameters: [
	+ Operation.parameter(
	+ :godmode,
	+ :query,
	+ %Schema{type: :boolean, default: false},
	+ "Allows to see private statuses"
	+ ),
	+ Operation.parameter(
	+ :local_only,
	+ :query,
	+ %Schema{type: :boolean, default: false},
	+ "Excludes remote statuses"
	+ ),
	+ Operation.parameter(
	+ :with_reblogs,
	+ :query,
	+ %Schema{type: :boolean, default: false},
	+ "Allows to see reblogs"
	+ ),
	+ Operation.parameter(
	+ :page,
	+ :query,
	+ %Schema{type: :integer, default: 1},
	+ "Page"
	+ ),
	+ Operation.parameter(
	+ :page_size,
	+ :query,
	+ %Schema{type: :integer, default: 50},
	+ "Number of statuses to return"
	+ )
	+ ],
	+ responses: %{
	+ 200 =>
	+ Operation.response("Array of statuses", "application/json", %Schema{
	+ type: :array,
	+ items: status()
	+ })
	+ }
	+ }
	+ end
	+
	+ def show_operation do
	+ %Operation{
	+ tags: ["Admin", "Statuses"],
	+ summary: "Show Status",
	+ operationId: "AdminAPI.StatusController.show",
	+ parameters: [id_param()],
	+ security: [%{"oAuth" => ["read:statuses"]}],
	+ responses: %{
	+ 200 => Operation.response("Status", "application/json", Status),
	+ 404 => Operation.response("Not Found", "application/json", ApiError)
	+ }
	+ }
	+ end
	+
	+ def update_operation do
	+ %Operation{
	+ tags: ["Admin", "Statuses"],
	+ summary: "Change the scope of an individual reported status",
	+ operationId: "AdminAPI.StatusController.update",
	+ parameters: [id_param()],
	+ security: [%{"oAuth" => ["write:statuses"]}],
	+ requestBody: request_body("Parameters", update_request(), required: true),
	+ responses: %{
	+ 200 => Operation.response("Status", "application/json", Status),
	+ 400 => Operation.response("Error", "application/json", ApiError)
	+ }
	+ }
	+ end
	+
	+ def delete_operation do
	+ %Operation{
	+ tags: ["Admin", "Statuses"],
	+ summary: "Delete an individual reported status",
	+ operationId: "AdminAPI.StatusController.delete",
	+ parameters: [id_param()],
	+ security: [%{"oAuth" => ["write:statuses"]}],
	+ responses: %{
	+ 200 => empty_object_response(),
	+ 404 => Operation.response("Not Found", "application/json", ApiError)
	+ }
	+ }
	+ end
	+
	+ defp status do
	+ %Schema{
	+ anyOf: [
	+ Status,
	+ %Schema{
	+ type: :object,
	+ properties: %{
	+ account: %Schema{allOf: [Account, admin_account()]}
	+ }
	+ }
	+ ]
	+ }
	+ end
	+
	+ defp admin_account do
	+ %Schema{
	+ type: :object,
	+ properties: %{
	+ id: FlakeID,
	+ avatar: %Schema{type: :string},
	+ nickname: %Schema{type: :string},
	+ display_name: %Schema{type: :string},
	+ deactivated: %Schema{type: :boolean},
	+ local: %Schema{type: :boolean},
	+ roles: %Schema{
	+ type: :object,
	+ properties: %{
	+ admin: %Schema{type: :boolean},
	+ moderator: %Schema{type: :boolean}
	+ }
	+ },
	+ tags: %Schema{type: :string},
	+ confirmation_pending: %Schema{type: :string}
	+ }
	+ }
	+ end
	+
	+ defp update_request do
	+ %Schema{
	+ type: :object,
	+ properties: %{
	+ sensitive: %Schema{
	+ type: :boolean,
	+ description: "Mark status and attached media as sensitive?"
	+ },
	+ visibility: VisibilityScope
	+ },
	+ example: %{
	+ "visibility" => "private",
	+ "sensitive" => "false"
	+ }
	+ }
	+ end
	+end
	diff --git a/lib/pleroma/web/api_spec/operations/status_operation.ex b/lib/pleroma/web/api_spec/operations/status_operation.ex
	index 0682ca6e5..ca9db01e5 100644
	--- a/lib/pleroma/web/api_spec/operations/status_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/status_operation.ex
	@@ -1,518 +1,518 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.StatusOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.AccountOperation
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.Schemas.ScheduledStatus
	alias Pleroma.Web.ApiSpec.Schemas.Status
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	import Pleroma.Web.ApiSpec.Helpers

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

	def index_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Get multiple statuses by IDs",
	security: [%{"oAuth" => ["read:statuses"]}],
	parameters: [
	Operation.parameter(
	:ids,
	:query,
	%Schema{type: :array, items: FlakeID},
	"Array of status IDs"
	)
	],
	operationId: "StatusController.index",
	responses: %{
	200 => Operation.response("Array of Status", "application/json", array_of_statuses())
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Publish new status",
	security: [%{"oAuth" => ["write:statuses"]}],
	description: "Post a new status",
	operationId: "StatusController.create",
	requestBody: request_body("Parameters", create_request(), required: true),
	responses: %{
	200 =>
	Operation.response(
	"Status. When `scheduled_at` is present, ScheduledStatus is returned instead",
	"application/json",
	%Schema{oneOf: [Status, ScheduledStatus]}
	),
	422 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "View specific status",
	description: "View information about a status",
	operationId: "StatusController.show",
	security: [%{"oAuth" => ["read:statuses"]}],
	parameters: [id_param()],
	responses: %{
	200 => status_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Delete status",
	security: [%{"oAuth" => ["write:statuses"]}],
	description: "Delete one of your own statuses",
	operationId: "StatusController.delete",
	parameters: [id_param()],
	responses: %{
	200 => empty_object_response(),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def reblog_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Boost",
	security: [%{"oAuth" => ["write:statuses"]}],
	description: "Share a status",
	operationId: "StatusController.reblog",
	parameters: [id_param()],
	requestBody:
	request_body("Parameters", %Schema{
	type: :object,
	properties: %{
	visibility: %Schema{allOf: [VisibilityScope], default: "public"}
	}
	}),
	responses: %{
	200 => status_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def unreblog_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Undo boost",
	security: [%{"oAuth" => ["write:statuses"]}],
	description: "Undo a reshare of a status",
	operationId: "StatusController.unreblog",
	parameters: [id_param()],
	responses: %{
	200 => status_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def favourite_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Favourite",
	security: [%{"oAuth" => ["write:favourites"]}],
	description: "Add a status to your favourites list",
	operationId: "StatusController.favourite",
	parameters: [id_param()],
	responses: %{
	200 => status_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def unfavourite_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Undo favourite",
	security: [%{"oAuth" => ["write:favourites"]}],
	description: "Remove a status from your favourites list",
	operationId: "StatusController.unfavourite",
	parameters: [id_param()],
	responses: %{
	200 => status_response(),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def pin_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Pin to profile",
	security: [%{"oAuth" => ["write:accounts"]}],
	description: "Feature one of your own public statuses at the top of your profile",
	operationId: "StatusController.pin",
	parameters: [id_param()],
	responses: %{
	200 => status_response(),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def unpin_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Unpin to profile",
	security: [%{"oAuth" => ["write:accounts"]}],
	description: "Unfeature a status from the top of your profile",
	operationId: "StatusController.unpin",
	parameters: [id_param()],
	responses: %{
	200 => status_response(),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def bookmark_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Bookmark",
	security: [%{"oAuth" => ["write:bookmarks"]}],
	description: "Privately bookmark a status",
	operationId: "StatusController.bookmark",
	parameters: [id_param()],
	responses: %{
	200 => status_response()
	}
	}
	end

	def unbookmark_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Undo bookmark",
	security: [%{"oAuth" => ["write:bookmarks"]}],
	description: "Remove a status from your private bookmarks",
	operationId: "StatusController.unbookmark",
	parameters: [id_param()],
	responses: %{
	200 => status_response()
	}
	}
	end

	def mute_conversation_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Mute conversation",
	security: [%{"oAuth" => ["write:mutes"]}],
	description: "Do not receive notifications for the thread that this status is part of.",
	operationId: "StatusController.mute_conversation",
	parameters: [id_param()],
	responses: %{
	200 => status_response(),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def unmute_conversation_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Unmute conversation",
	security: [%{"oAuth" => ["write:mutes"]}],
	description:
	"Start receiving notifications again for the thread that this status is part of",
	operationId: "StatusController.unmute_conversation",
	parameters: [id_param()],
	responses: %{
	200 => status_response(),
	400 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def card_operation do
	%Operation{
	tags: ["Statuses"],
	deprecated: true,
	summary: "Preview card",
	description: "Deprecated in favor of card property inlined on Status entity",
	operationId: "StatusController.card",
	parameters: [id_param()],
	security: [%{"oAuth" => ["read:statuses"]}],
	responses: %{
	200 =>
	Operation.response("Card", "application/json", %Schema{
	type: :object,
	nullable: true,
	properties: %{
	type: %Schema{type: :string, enum: ["link", "photo", "video", "rich"]},
	provider_name: %Schema{type: :string, nullable: true},
	provider_url: %Schema{type: :string, format: :uri},
	url: %Schema{type: :string, format: :uri},
	image: %Schema{type: :string, nullable: true, format: :uri},
	title: %Schema{type: :string},
	description: %Schema{type: :string}
	}
	})
	}
	}
	end

	def favourited_by_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Favourited by",
	description: "View who favourited a given status",
	operationId: "StatusController.favourited_by",
	security: [%{"oAuth" => ["read:accounts"]}],
	parameters: [id_param()],
	responses: %{
	200 =>
	Operation.response(
	"Array of Accounts",
	"application/json",
	AccountOperation.array_of_accounts()
	),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def reblogged_by_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Boosted by",
	description: "View who boosted a given status",
	operationId: "StatusController.reblogged_by",
	security: [%{"oAuth" => ["read:accounts"]}],
	parameters: [id_param()],
	responses: %{
	200 =>
	Operation.response(
	"Array of Accounts",
	"application/json",
	AccountOperation.array_of_accounts()
	),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def context_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Parent and child statuses",
	description: "View statuses above and below this status in the thread",
	operationId: "StatusController.context",
	security: [%{"oAuth" => ["read:statuses"]}],
	parameters: [id_param()],
	responses: %{
	200 => Operation.response("Context", "application/json", context())
	}
	}
	end

	def favourites_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Favourited statuses",
	description: "Statuses the user has favourited",
	operationId: "StatusController.favourites",
	parameters: pagination_params(),
	security: [%{"oAuth" => ["read:favourites"]}],
	responses: %{
	200 => Operation.response("Array of Statuses", "application/json", array_of_statuses())
	}
	}
	end

	def bookmarks_operation do
	%Operation{
	tags: ["Statuses"],
	summary: "Bookmarked statuses",
	description: "Statuses the user has bookmarked",
	operationId: "StatusController.bookmarks",
	parameters: pagination_params(),
	security: [%{"oAuth" => ["read:bookmarks"]}],
	responses: %{
	200 => Operation.response("Array of Statuses", "application/json", array_of_statuses())
	}
	}
	end

	def array_of_statuses do
	%Schema{type: :array, items: Status, example: [Status.schema().example]}
	end

	defp create_request do
	%Schema{
	title: "StatusCreateRequest",
	type: :object,
	properties: %{
	status: %Schema{
	type: :string,
	nullable: true,
	description:
	"Text content of the status. If `media_ids` is provided, this becomes optional. Attaching a `poll` is optional while `status` is provided."
	},
	media_ids: %Schema{
	nullable: true,
	type: :array,
	items: %Schema{type: :string},
	description: "Array of Attachment ids to be attached as media."
	},
	poll: %Schema{
	nullable: true,
	type: :object,
	required: [:options],
	properties: %{
	options: %Schema{
	type: :array,
	items: %Schema{type: :string},
	description: "Array of possible answers. Must be provided with `poll[expires_in]`."
	},
	expires_in: %Schema{
	type: :integer,
	nullable: true,
	description:
	"Duration the poll should be open, in seconds. Must be provided with `poll[options]`"
	},
	multiple: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Allow multiple choices?"
	},
	hide_totals: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Hide vote counts until the poll ends?"
	}
	}
	},
	in_reply_to_id: %Schema{
	nullable: true,
	allOf: [FlakeID],
	description: "ID of the status being replied to, if status is a reply"
	},
	sensitive: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Mark status and attached media as sensitive?"
	},
	spoiler_text: %Schema{
	type: :string,
	nullable: true,
	description:
	"Text to be shown as a warning or subject before the actual content. Statuses are generally collapsed behind this field."
	},
	scheduled_at: %Schema{
	type: :string,
	format: :"date-time",
	nullable: true,
	description:
	"ISO 8601 Datetime at which to schedule a status. Providing this paramter will cause ScheduledStatus to be returned instead of Status. Must be at least 5 minutes in the future."
	},
	language: %Schema{
	type: :string,
	nullable: true,
	description: "ISO 639 language code for this status."
	},
	# Pleroma-specific properties:
	preview: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description:
	"If set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example"
	},
	content_type: %Schema{
	type: :string,
	nullable: true,
	description:
	"The MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint."
	},
	to: %Schema{
	type: :array,
	nullable: true,
	items: %Schema{type: :string},
	description:
	"A list of nicknames (like `lain@soykaf.club` or `lain` on the local server) that will be used to determine who is going to be addressed by this post. Using this will disable the implicit addressing by mentioned names in the `status` body, only the people in the `to` list will be addressed. The normal rules for for post visibility are not affected by this and will still apply"
	},
	visibility: %Schema{
	nullable: true,
	anyOf: [
	VisibilityScope,
	%Schema{type: :string, description: "`list:LIST_ID`", example: "LIST:123"}
	],
	description:
	"Visibility of the posted status. Besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`"
	},
	expires_in: %Schema{
	nullable: true,
	type: :integer,
	description:
	"The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour."
	},
	in_reply_to_conversation_id: %Schema{
	nullable: true,
	type: :string,
	description:
	"Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`."
	}
	},
	example: %{
	"status" => "What time is it?",
	"sensitive" => "false",
	"poll" => %{
	"options" => ["Cofe", "Adventure"],
	"expires_in" => 420
	}
	}
	}
	end

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

	defp status_response do
	Operation.response("Status", "application/json", Status)
	end

	defp context do
	%Schema{
	title: "StatusContext",
	description:
	"Represents the tree around a given status. Used for reconstructing threads of statuses.",
	type: :object,
	required: [:ancestors, :descendants],
	properties: %{
	ancestors: array_of_statuses(),
	descendants: array_of_statuses()
	},
	example: %{
	"ancestors" => [Status.schema().example],
	"descendants" => [Status.schema().example]
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index 1c0d90a2b..6ec489f9a 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,572 +1,576 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Utils do
	import Pleroma.Web.Gettext
	import Pleroma.Web.ControllerHelper, only: [truthy_param?: 1]

	alias Calendar.Strftime
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.Plugs.AuthenticationPlug
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.MediaProxy

	require Logger
	require Pleroma.Constants

	def attachments_from_ids(%{media_ids: ids, descriptions: desc}) do
	attachments_from_ids_descs(ids, desc)
	end

	def attachments_from_ids(%{media_ids: ids}) do
	attachments_from_ids_no_descs(ids)
	end

	def attachments_from_ids(_), do: []

	def attachments_from_ids_no_descs([]), do: []

	def attachments_from_ids_no_descs(ids) do
	Enum.map(ids, fn media_id ->
	case Repo.get(Object, media_id) do
	%Object{data: data} -> data
	_ -> nil
	end
	end)
	\|> Enum.reject(&is_nil/1)
	end

	def attachments_from_ids_descs([], _), do: []

	def attachments_from_ids_descs(ids, descs_str) do
	{_, descs} = Jason.decode(descs_str)

	Enum.map(ids, fn media_id ->
	case Repo.get(Object, media_id) do
	%Object{data: data} ->
	Map.put(data, "name", descs[media_id])

	_ ->
	nil
	end
	end)
	\|> Enum.reject(&is_nil/1)
	end

	@spec get_to_and_cc(
	User.t(),
	list(String.t()),
	Activity.t() \| nil,
	String.t(),
	Participation.t() \| nil
	) :: {list(String.t()), list(String.t())}

	def get_to_and_cc(_, _, _, _, %Participation{} = participation) do
	participation = Repo.preload(participation, :recipients)
	{Enum.map(participation.recipients, & &1.ap_id), []}
	end

	def get_to_and_cc(user, mentioned_users, inReplyTo, "public", _) do
	to = [Pleroma.Constants.as_public() \| mentioned_users]
	cc = [user.follower_address]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def get_to_and_cc(user, mentioned_users, inReplyTo, "unlisted", _) do
	to = [user.follower_address \| mentioned_users]
	cc = [Pleroma.Constants.as_public()]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def get_to_and_cc(user, mentioned_users, inReplyTo, "private", _) do
	{to, cc} = get_to_and_cc(user, mentioned_users, inReplyTo, "direct", nil)
	{[user.follower_address \| to], cc}
	end

	def get_to_and_cc(_user, mentioned_users, inReplyTo, "direct", _) do
	# If the OP is a DM already, add the implicit actor.
	if inReplyTo && Visibility.is_direct?(inReplyTo) do
	{Enum.uniq([inReplyTo.data["actor"] \| mentioned_users]), []}
	else
	{mentioned_users, []}
	end
	end

	def get_to_and_cc(_user, mentions, _inReplyTo, {:list, _}, _), do: {mentions, []}

	def get_addressed_users(_, to) when is_list(to) do
	User.get_ap_ids_by_nicknames(to)
	end

	def get_addressed_users(mentioned_users, _), do: mentioned_users

	def maybe_add_list_data(activity_params, user, {:list, list_id}) do
	case Pleroma.List.get(list_id, user) do
	%Pleroma.List{} = list ->
	activity_params
	\|> put_in([:additional, "bcc"], [list.ap_id])
	\|> put_in([:additional, "listMessage"], list.ap_id)
	\|> put_in([:object, "listMessage"], list.ap_id)

	_ ->
	activity_params
	end
	end

	def maybe_add_list_data(activity_params, _, _), do: activity_params

	def make_poll_data(%{"poll" => %{"expires_in" => expires_in}} = data)
	when is_binary(expires_in) do
	# In some cases mastofe sends out strings instead of integers
	data
	\|> put_in(["poll", "expires_in"], String.to_integer(expires_in))
	\|> make_poll_data()
	end

	def make_poll_data(%{poll: %{options: options, expires_in: expires_in}} = data)
	when is_list(options) do
	limits = Pleroma.Config.get([:instance, :poll_limits])

	with :ok <- validate_poll_expiration(expires_in, limits),
	:ok <- validate_poll_options_amount(options, limits),
	:ok <- validate_poll_options_length(options, limits) do
	{option_notes, emoji} =
	Enum.map_reduce(options, %{}, fn option, emoji ->
	note = %{
	"name" => option,
	"type" => "Note",
	"replies" => %{"type" => "Collection", "totalItems" => 0}
	}

	{note, Map.merge(emoji, Pleroma.Emoji.Formatter.get_emoji_map(option))}
	end)

	end_time =
	DateTime.utc_now()
	\|> DateTime.add(expires_in)
	\|> DateTime.to_iso8601()

	key = if truthy_param?(data.poll[:multiple]), do: "anyOf", else: "oneOf"
	poll = %{"type" => "Question", key => option_notes, "closed" => end_time}

	{:ok, {poll, emoji}}
	end
	end

	def make_poll_data(%{"poll" => poll}) when is_map(poll) do
	{:error, "Invalid poll"}
	end

	def make_poll_data(_data) do
	{:ok, {%{}, %{}}}
	end

	defp validate_poll_options_amount(options, %{max_options: max_options}) do
	if Enum.count(options) > max_options do
	{:error, "Poll can't contain more than #{max_options} options"}
	else
	:ok
	end
	end

	defp validate_poll_options_length(options, %{max_option_chars: max_option_chars}) do
	if Enum.any?(options, &(String.length(&1) > max_option_chars)) do
	{:error, "Poll options cannot be longer than #{max_option_chars} characters each"}
	else
	:ok
	end
	end

	defp validate_poll_expiration(expires_in, %{min_expiration: min, max_expiration: max}) do
	cond do
	expires_in > max -> {:error, "Expiration date is too far in the future"}
	expires_in < min -> {:error, "Expiration date is too soon"}
	true -> :ok
	end
	end

	def make_content_html(
	status,
	attachments,
	data,
	visibility
	) do
	attachment_links =
	data
	\|> Map.get("attachment_links", Config.get([:instance, :attachment_links]))
	\|> truthy_param?()

	content_type = get_content_type(data[:content_type])

	options =
	if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
	[safe_mention: true]
	else
	[]
	end

	status
	\|> format_input(content_type, options)
	\|> maybe_add_attachments(attachments, attachment_links)
	\|> maybe_add_nsfw_tag(data)
	end

	defp get_content_type(content_type) do
	if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
	content_type
	else
	"text/plain"
	end
	end

	defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
	when sensitive in [true, "True", "true", "1"] do
	{text, mentions, [{"#nsfw", "nsfw"} \| tags]}
	end

	defp maybe_add_nsfw_tag(data, _), do: data

	def make_context(_, %Participation{} = participation) do
	Repo.preload(participation, :conversation).conversation.ap_id
	end

	def make_context(%Activity{data: %{"context" => context}}, _), do: context
	def make_context(_, _), do: Utils.generate_context_id()

	def maybe_add_attachments(parsed, _attachments, false = _no_links), do: parsed

	def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
	text = add_attachments(text, attachments)
	{text, mentions, tags}
	end

	def add_attachments(text, attachments) do
	attachment_text = Enum.map(attachments, &build_attachment_link/1)
	Enum.join([text \| attachment_text], "<br>")
	end

	defp build_attachment_link(%{"url" => [%{"href" => href} \| _]} = attachment) do
	name = attachment["name"] \|\| URI.decode(Path.basename(href))
	href = MediaProxy.url(href)
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"
	end

	defp build_attachment_link(_), do: ""

	def format_input(text, format, options \\ [])

	@doc """
	Formatting text to plain text.
	"""
	def format_input(text, "text/plain", options) do
	text
	\|> Formatter.html_escape("text/plain")
	\|> Formatter.linkify(options)
	\|> (fn {text, mentions, tags} ->
	{String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
	end).()
	end

	@doc """
	Formatting text as BBCode.
	"""
	def format_input(text, "text/bbcode", options) do
	text
	\|> String.replace(~r/\r/, "")
	\|> Formatter.html_escape("text/plain")
	\|> BBCode.to_html()
	\|> (fn {:ok, html} -> html end).()
	\|> Formatter.linkify(options)
	end

	@doc """
	Formatting text to html.
	"""
	def format_input(text, "text/html", options) do
	text
	\|> Formatter.html_escape("text/html")
	\|> Formatter.linkify(options)
	end

	@doc """
	Formatting text to markdown.
	"""
	def format_input(text, "text/markdown", options) do
	text
	\|> Formatter.mentions_escape(options)
	\|> Earmark.as_html!(%Earmark.Options{renderer: Pleroma.EarmarkRenderer})
	\|> Formatter.linkify(options)
	\|> Formatter.html_escape("text/html")
	end

	def make_note_data(
	actor,
	to,
	context,
	content_html,
	attachments,
	in_reply_to,
	tags,
	summary \\ nil,
	cc \\ [],
	sensitive \\ false,
	extra_params \\ %{}
	) do
	%{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => content_html,
	"summary" => summary,
	"sensitive" => truthy_param?(sensitive),
	"context" => context,
	"attachment" => attachments,
	"actor" => actor,
	"tag" => Keyword.values(tags) \|> Enum.uniq()
	}
	\|> add_in_reply_to(in_reply_to)
	\|> Map.merge(extra_params)
	end

	defp add_in_reply_to(object, nil), do: object

	defp add_in_reply_to(object, in_reply_to) do
	with %Object{} = in_reply_to_object <- Object.normalize(in_reply_to) do
	Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
	else
	_ -> object
	end
	end

	def format_naive_asctime(date) do
	date \|> DateTime.from_naive!("Etc/UTC") \|> format_asctime
	end

	def format_asctime(date) do
	Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	end

	def date_to_asctime(date) when is_binary(date) do
	with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
	format_asctime(date)
	else
	_e ->
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end
	end

	def date_to_asctime(date) do
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end

	def to_masto_date(%NaiveDateTime{} = date) do
	date
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	end

	def to_masto_date(date) when is_binary(date) do
	with {:ok, date} <- NaiveDateTime.from_iso8601(date) do
	to_masto_date(date)
	else
	_ -> ""
	end
	end

	def to_masto_date(_), do: ""

	defp shortname(name) do
	with max_length when max_length > 0 <-
	Config.get([Pleroma.Upload, :filename_display_max_length], 30),
	true <- String.length(name) > max_length do
	String.slice(name, 0..max_length) <> "…"
	else
	_ -> name
	end
	end

	@spec confirm_current_password(User.t(), String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def confirm_current_password(user, password) do
	with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
	true <- AuthenticationPlug.checkpw(password, db_user.password_hash) do
	{:ok, db_user}
	else
	_ -> {:error, dgettext("errors", "Invalid password.")}
	end
	end

	def maybe_notify_to_recipients(
	recipients,
	%Activity{data: %{"to" => to, "type" => _type}} = _activity
	) do
	recipients ++ to
	end

	def maybe_notify_to_recipients(recipients, _), do: recipients

	def maybe_notify_mentioned_recipients(
	recipients,
	%Activity{data: %{"to" => _to, "type" => type} = data} = activity
	)
	when type == "Create" do
	object = Object.normalize(activity)

	object_data =
	cond do
	not is_nil(object) ->
	object.data

	is_map(data["object"]) ->
	data["object"]

	true ->
	%{}
	end

	tagged_mentions = maybe_extract_mentions(object_data)

	recipients ++ tagged_mentions
	end

	def maybe_notify_mentioned_recipients(recipients, _), do: recipients

	# Do not notify subscribers if author is making a reply
	def maybe_notify_subscribers(recipients, %Activity{
	object: %Object{data: %{"inReplyTo" => _ap_id}}
	}) do
	recipients
	end

	def maybe_notify_subscribers(
	recipients,
	%Activity{data: %{"actor" => actor, "type" => type}} = activity
	)
	when type == "Create" do
	with %User{} = user <- User.get_cached_by_ap_id(actor) do
	subscriber_ids =
	user
	\|> User.subscriber_users()
	\|> Enum.filter(&Visibility.visible_for_user?(activity, &1))
	\|> Enum.map(& &1.ap_id)

	recipients ++ subscriber_ids
	+ else
	+ _e -> recipients
	end
	end

	def maybe_notify_subscribers(recipients, _), do: recipients

	def maybe_notify_followers(recipients, %Activity{data: %{"type" => "Move"}} = activity) do
	with %User{} = user <- User.get_cached_by_ap_id(activity.actor) do
	user
	\|> User.get_followers()
	\|> Enum.map(& &1.ap_id)
	\|> Enum.concat(recipients)
	+ else
	+ _e -> recipients
	end
	end

	def maybe_notify_followers(recipients, _), do: recipients

	def maybe_extract_mentions(%{"tag" => tag}) do
	tag
	\|> Enum.filter(fn x -> is_map(x) && x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	\|> Enum.uniq()
	end

	def maybe_extract_mentions(_), do: []

	def make_report_content_html(nil), do: {:ok, {nil, [], []}}

	def make_report_content_html(comment) do
	max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)

	if String.length(comment) <= max_size do
	{:ok, format_input(comment, "text/plain")}
	else
	{:error,
	dgettext("errors", "Comment must be up to %{max_size} characters", max_size: max_size)}
	end
	end

	def get_report_statuses(%User{ap_id: actor}, %{status_ids: status_ids})
	when is_list(status_ids) do
	{:ok, Activity.all_by_actor_and_id(actor, status_ids)}
	end

	def get_report_statuses(_, _), do: {:ok, nil}

	# DEPRECATED mostly, context objects are now created at insertion time.
	def context_to_conversation_id(context) do
	with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
	id
	else
	_e ->
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, %{id: id}} ->
	id

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context).id
	end
	end
	end

	def conversation_id_to_context(id) do
	with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
	context
	else
	_e ->
	{:error, dgettext("errors", "No such conversation")}
	end
	end

	def make_answer_data(%User{ap_id: ap_id}, object, name) do
	%{
	"type" => "Answer",
	"actor" => ap_id,
	"cc" => [object.data["actor"]],
	"to" => [],
	"name" => name,
	"inReplyTo" => object.data["id"]
	}
	end

	def validate_character_limit("" = _full_payload, [] = _attachments) do
	{:error, dgettext("errors", "Cannot post an empty status without attachments")}
	end

	def validate_character_limit(full_payload, _attachments) do
	limit = Pleroma.Config.get([:instance, :limit])
	length = String.length(full_payload)

	if length <= limit do
	:ok
	else
	{:error, dgettext("errors", "The status is over the character limit")}
	end
	end
	end
	diff --git a/lib/pleroma/web/feed/user_controller.ex b/lib/pleroma/web/feed/user_controller.ex
	index 1b72e23dc..5a6fc9de0 100644
	--- a/lib/pleroma/web/feed/user_controller.ex
	+++ b/lib/pleroma/web/feed/user_controller.ex
	@@ -1,81 +1,81 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Feed.UserController do
	use Pleroma.Web, :controller

	alias Fallback.RedirectController
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ActivityPubController
	alias Pleroma.Web.Feed.FeedView

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

	plug(Pleroma.Plugs.SetFormatPlug when action in [:feed_redirect])

	action_fallback(:errors)

	def feed_redirect(%{assigns: %{format: "html"}} = conn, %{"nickname" => nickname}) do
	with {_, %User{} = user} <- {:fetch_user, User.get_cached_by_nickname_or_id(nickname)} do
	RedirectController.redirector_with_meta(conn, %{user: user})
	end
	end

	def feed_redirect(%{assigns: %{format: format}} = conn, _params)
	when format in ["json", "activity+json"] do
	with %{halted: false} = conn <-
	Pleroma.Plugs.EnsureAuthenticatedPlug.call(conn,
	unless_func: &Pleroma.Web.FederatingPlug.federating?/1
	) do
	ActivityPubController.call(conn, :user)
	end
	end

	def feed_redirect(conn, %{"nickname" => nickname}) do
	with {_, %User{} = user} <- {:fetch_user, User.get_cached_by_nickname(nickname)} do
	redirect(conn, external: "#{user_feed_url(conn, :feed, user.nickname)}.atom")
	end
	end

	def feed(conn, %{"nickname" => nickname} = params) do
	format = get_format(conn)

	format =
	if format in ["rss", "atom"] do
	format
	else
	"atom"
	end

	with {_, %User{} = user} <- {:fetch_user, User.get_cached_by_nickname(nickname)} do
	activities =
	%{
	"type" => ["Create"],
	"actor_id" => user.ap_id
	}
	\|> put_if_exist("max_id", params["max_id"])
	- \|> ActivityPub.fetch_public_activities()
	+ \|> ActivityPub.fetch_public_or_unlisted_activities()

	conn
	\|> put_resp_content_type("application/#{format}+xml")
	\|> put_view(FeedView)
	\|> render("user.#{format}",
	user: user,
	activities: activities,
	feed_config: Pleroma.Config.get([:feed])
	)
	end
	end

	def errors(conn, {:error, :not_found}) do
	render_error(conn, :not_found, "Not found")
	end

	def errors(conn, {:fetch_user, nil}), do: errors(conn, {:error, :not_found})

	def errors(conn, _) do
	render_error(conn, :internal_server_error, "Something went wrong")
	end
	end
	diff --git a/lib/pleroma/web/ostatus/ostatus_controller.ex b/lib/pleroma/web/ostatus/ostatus_controller.ex
	index 6971cd9f8..de1b0b3f0 100644
	--- a/lib/pleroma/web/ostatus/ostatus_controller.ex
	+++ b/lib/pleroma/web/ostatus/ostatus_controller.ex
	@@ -1,151 +1,151 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.OStatusController do
	use Pleroma.Web, :controller

	alias Fallback.RedirectController
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Plugs.RateLimiter
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPubController
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Metadata.PlayerView
	alias Pleroma.Web.Router

	plug(Pleroma.Plugs.EnsureAuthenticatedPlug,
	unless_func: &Pleroma.Web.FederatingPlug.federating?/1
	)

	plug(
	RateLimiter,
	[name: :ap_routes, params: ["uuid"]] when action in [:object, :activity]
	)

	plug(
	Pleroma.Plugs.SetFormatPlug
	when action in [:object, :activity, :notice]
	)

	action_fallback(:errors)

	- def object(%{assigns: %{format: format}} = conn, %{"uuid" => _uuid})
	+ def object(%{assigns: %{format: format}} = conn, _params)
	when format in ["json", "activity+json"] do
	ActivityPubController.call(conn, :object)
	end

	- def object(%{assigns: %{format: format}} = conn, %{"uuid" => uuid}) do
	- with id <- o_status_url(conn, :object, uuid),
	+ def object(%{assigns: %{format: format}} = conn, _params) do
	+ with id <- Endpoint.url() <> conn.request_path,
	{_, %Activity{} = activity} <-
	{:activity, Activity.get_create_by_object_ap_id_with_object(id)},
	{_, true} <- {:public?, Visibility.is_public?(activity)} do
	case format do
	_ -> redirect(conn, to: "/notice/#{activity.id}")
	end
	else
	reason when reason in [{:public?, false}, {:activity, nil}] ->
	{:error, :not_found}

	e ->
	e
	end
	end

	- def activity(%{assigns: %{format: format}} = conn, %{"uuid" => _uuid})
	+ def activity(%{assigns: %{format: format}} = conn, _params)
	when format in ["json", "activity+json"] do
	ActivityPubController.call(conn, :activity)
	end

	- def activity(%{assigns: %{format: format}} = conn, %{"uuid" => uuid}) do
	- with id <- o_status_url(conn, :activity, uuid),
	+ def activity(%{assigns: %{format: format}} = conn, _params) do
	+ with id <- Endpoint.url() <> conn.request_path,
	{_, %Activity{} = activity} <- {:activity, Activity.normalize(id)},
	{_, true} <- {:public?, Visibility.is_public?(activity)} do
	case format do
	_ -> redirect(conn, to: "/notice/#{activity.id}")
	end
	else
	reason when reason in [{:public?, false}, {:activity, nil}] ->
	{:error, :not_found}

	e ->
	e
	end
	end

	def notice(%{assigns: %{format: format}} = conn, %{"id" => id}) do
	with {_, %Activity{} = activity} <- {:activity, Activity.get_by_id_with_object(id)},
	{_, true} <- {:public?, Visibility.is_public?(activity)},
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	cond do
	format in ["json", "activity+json"] ->
	if activity.local do
	%{data: %{"id" => redirect_url}} = Object.normalize(activity)
	redirect(conn, external: redirect_url)
	else
	{:error, :not_found}
	end

	activity.data["type"] == "Create" ->
	%Object{} = object = Object.normalize(activity)

	RedirectController.redirector_with_meta(
	conn,
	%{
	activity_id: activity.id,
	object: object,
	url: Router.Helpers.o_status_url(Endpoint, :notice, activity.id),
	user: user
	}
	)

	true ->
	RedirectController.redirector(conn, nil)
	end
	else
	reason when reason in [{:public?, false}, {:activity, nil}] ->
	conn
	\|> put_status(404)
	\|> RedirectController.redirector(nil, 404)

	e ->
	e
	end
	end

	# Returns an HTML embedded <audio> or <video> player suitable for embed iframes.
	def notice_player(conn, %{"id" => id}) do
	with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.is_public?(activity),
	%Object{} = object <- Object.normalize(activity),
	%{data: %{"attachment" => [%{"url" => [url \| _]} \| _]}} <- object,
	true <- String.starts_with?(url["mediaType"], ["audio", "video"]) do
	conn
	\|> put_layout(:metadata_player)
	\|> put_resp_header("x-frame-options", "ALLOW")
	\|> put_resp_header(
	"content-security-policy",
	"default-src 'none';style-src 'self' 'unsafe-inline';img-src 'self' data: https:; media-src 'self' https:;"
	)
	\|> put_view(PlayerView)
	\|> render("player.html", url)
	else
	_error ->
	conn
	\|> put_status(404)
	\|> RedirectController.redirector(nil, 404)
	end
	end

	defp errors(conn, {:error, :not_found}) do
	render_error(conn, :not_found, "Not found")
	end

	defp errors(conn, {:fetch_user, nil}), do: errors(conn, {:error, :not_found})

	defp errors(conn, _) do
	render_error(conn, :internal_server_error, "Something went wrong")
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index cbe320746..e493a4153 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,719 +1,723 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

	pipeline :browser do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	end

	pipeline :oauth do
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	end

	pipeline :expect_authentication do
	plug(Pleroma.Plugs.ExpectAuthenticatedCheckPlug)
	end

	pipeline :expect_public_instance_or_authentication do
	plug(Pleroma.Plugs.ExpectPublicOrAuthenticatedCheckPlug)
	end

	pipeline :authenticate do
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	end

	pipeline :after_auth do
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :base_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(:authenticate)
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :api do
	plug(:expect_public_instance_or_authentication)
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :authenticated_api do
	plug(:expect_authentication)
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :admin_api do
	plug(:expect_authentication)
	plug(:base_api)
	plug(Pleroma.Plugs.AdminSecretAuthenticationPlug)
	plug(:after_auth)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.UserIsAdminPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :mastodon_html do
	plug(:browser)
	plug(:authenticate)
	plug(:after_auth)
	end

	pipeline :pleroma_html do
	plug(:browser)
	plug(:authenticate)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :well_known do
	plug(:accepts, ["json", "jrd+json", "xml", "xrd+xml"])
	end

	pipeline :config do
	plug(:accepts, ["json", "xml"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :pleroma_api do
	plug(:accepts, ["html", "json"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :mailbox_preview do
	plug(:accepts, ["html"])

	plug(:put_secure_browser_headers, %{
	"content-security-policy" =>
	"default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline' 'unsafe-eval'"
	})
	end

	pipeline :http_signature do
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	plug(Pleroma.Web.Plugs.MappedSignatureToIdentityPlug)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)

	get("/password_reset/:token", PasswordController, :reset, as: :reset_password)
	post("/password_reset", PasswordController, :do_reset, as: :reset_password)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	get("/healthcheck", UtilController, :healthcheck)
	end

	scope "/api/pleroma", Pleroma.Web do
	pipe_through(:pleroma_api)
	post("/uploader_callback/:upload_path", UploaderController, :callback)
	end

	scope "/api/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:admin_api)

	post("/users/follow", AdminAPIController, :user_follow)
	post("/users/unfollow", AdminAPIController, :user_unfollow)

	put("/users/disable_mfa", AdminAPIController, :disable_mfa)
	delete("/users", AdminAPIController, :user_delete)
	post("/users", AdminAPIController, :users_create)
	patch("/users/:nickname/toggle_activation", AdminAPIController, :user_toggle_activation)
	patch("/users/activate", AdminAPIController, :user_activate)
	patch("/users/deactivate", AdminAPIController, :user_deactivate)
	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)

	get("/users/:nickname/permission_group", AdminAPIController, :right_get)
	get("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_get)

	post("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_add)

	delete(
	"/users/:nickname/permission_group/:permission_group",
	AdminAPIController,
	:right_delete
	)

	post("/users/permission_group/:permission_group", AdminAPIController, :right_add_multiple)

	delete(
	"/users/permission_group/:permission_group",
	AdminAPIController,
	:right_delete_multiple
	)

	get("/relay", AdminAPIController, :relay_list)
	post("/relay", AdminAPIController, :relay_follow)
	delete("/relay", AdminAPIController, :relay_unfollow)

	post("/users/invite_token", AdminAPIController, :create_invite_token)
	get("/users/invites", AdminAPIController, :invites)
	post("/users/revoke_invite", AdminAPIController, :revoke_invite)
	post("/users/email_invite", AdminAPIController, :email_invite)

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)
	patch("/users/force_password_reset", AdminAPIController, :force_password_reset)
	get("/users/:nickname/credentials", AdminAPIController, :show_user_credentials)
	patch("/users/:nickname/credentials", AdminAPIController, :update_user_credentials)

	get("/users", AdminAPIController, :list_users)
	get("/users/:nickname", AdminAPIController, :user_show)
	get("/users/:nickname/statuses", AdminAPIController, :list_user_statuses)

	get("/instances/:instance/statuses", AdminAPIController, :list_instance_statuses)

	patch("/users/confirm_email", AdminAPIController, :confirm_email)
	patch("/users/resend_confirmation_email", AdminAPIController, :resend_confirmation_email)

	get("/reports", AdminAPIController, :list_reports)
	get("/reports/:id", AdminAPIController, :report_show)
	patch("/reports", AdminAPIController, :reports_update)
	post("/reports/:id/notes", AdminAPIController, :report_notes_create)
	delete("/reports/:report_id/notes/:id", AdminAPIController, :report_notes_delete)

	- get("/statuses/:id", AdminAPIController, :status_show)
	- put("/statuses/:id", AdminAPIController, :status_update)
	- delete("/statuses/:id", AdminAPIController, :status_delete)
	- get("/statuses", AdminAPIController, :list_statuses)
	+ get("/statuses/:id", StatusController, :show)
	+ put("/statuses/:id", StatusController, :update)
	+ delete("/statuses/:id", StatusController, :delete)
	+ get("/statuses", StatusController, :index)

	get("/config", AdminAPIController, :config_show)
	post("/config", AdminAPIController, :config_update)
	get("/config/descriptions", AdminAPIController, :config_descriptions)
	get("/need_reboot", AdminAPIController, :need_reboot)
	get("/restart", AdminAPIController, :restart)

	get("/moderation_log", AdminAPIController, :list_log)

	post("/reload_emoji", AdminAPIController, :reload_emoji)
	get("/stats", AdminAPIController, :stats)

	get("/oauth_app", AdminAPIController, :oauth_app_list)
	post("/oauth_app", AdminAPIController, :oauth_app_create)
	patch("/oauth_app/:id", AdminAPIController, :oauth_app_update)
	delete("/oauth_app/:id", AdminAPIController, :oauth_app_delete)
	end

	scope "/api/pleroma/emoji", Pleroma.Web.PleromaAPI do
	# Modifying packs
	scope "/packs" do
	pipe_through(:admin_api)

	get("/import", EmojiPackController, :import_from_filesystem)
	get("/remote", EmojiPackController, :remote)
	post("/download", EmojiPackController, :download)

	post("/:name", EmojiPackController, :create)
	patch("/:name", EmojiPackController, :update)
	delete("/:name", EmojiPackController, :delete)

	post("/:name/files", EmojiPackController, :add_file)
	patch("/:name/files", EmojiPackController, :update_file)
	delete("/:name/files", EmojiPackController, :delete_file)
	end

	# Pack info / downloading
	scope "/packs" do
	pipe_through(:api)
	get("/", EmojiPackController, :index)
	get("/:name", EmojiPackController, :show)
	get("/:name/archive", EmojiPackController, :archive)
	end
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)

	post("/main/ostatus", UtilController, :remote_subscribe)
	get("/ostatus_subscribe", RemoteFollowController, :follow)

	post("/ostatus_subscribe", RemoteFollowController, :do_follow)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)

	post("/change_email", UtilController, :change_email)
	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	put("/notification_settings", UtilController, :update_notificaton_settings)
	post("/disable_account", UtilController, :disable_account)

	post("/blocks_import", UtilController, :blocks_import)
	post("/follow_import", UtilController, :follow_import)
	end

	scope "/api/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:authenticated_api)

	get("/accounts/mfa", TwoFactorAuthenticationController, :settings)
	get("/accounts/mfa/backup_codes", TwoFactorAuthenticationController, :backup_codes)
	get("/accounts/mfa/setup/:method", TwoFactorAuthenticationController, :setup)
	post("/accounts/mfa/confirm/:method", TwoFactorAuthenticationController, :confirm)
	delete("/accounts/mfa/:method", TwoFactorAuthenticationController, :disable)
	end

	scope "/oauth", Pleroma.Web.OAuth do
	scope [] do
	pipe_through(:oauth)
	get("/authorize", OAuthController, :authorize)
	end

	post("/authorize", OAuthController, :create_authorization)
	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	get("/registration_details", OAuthController, :registration_details)

	post("/mfa/challenge", MFAController, :challenge)
	post("/mfa/verify", MFAController, :verify, as: :mfa_verify)
	get("/mfa", MFAController, :show)

	scope [] do
	pipe_through(:browser)

	get("/prepare_request", OAuthController, :prepare_request)
	get("/:provider", OAuthController, :request)
	get("/:provider/callback", OAuthController, :callback)
	post("/register", OAuthController, :register)
	end
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)

	get("/statuses/:id/reactions/:emoji", EmojiReactionController, :index)
	get("/statuses/:id/reactions", EmojiReactionController, :index)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	scope [] do
	pipe_through(:authenticated_api)

	get("/conversations/:id/statuses", ConversationController, :statuses)
	get("/conversations/:id", ConversationController, :show)
	post("/conversations/read", ConversationController, :mark_as_read)
	patch("/conversations/:id", ConversationController, :update)

	put("/statuses/:id/reactions/:emoji", EmojiReactionController, :create)
	delete("/statuses/:id/reactions/:emoji", EmojiReactionController, :delete)
	post("/notifications/read", NotificationController, :mark_as_read)

	patch("/accounts/update_avatar", AccountController, :update_avatar)
	patch("/accounts/update_banner", AccountController, :update_banner)
	patch("/accounts/update_background", AccountController, :update_background)

	get("/mascot", MascotController, :show)
	put("/mascot", MascotController, :update)

	post("/scrobble", ScrobbleController, :create)
	end

	scope [] do
	pipe_through(:api)
	get("/accounts/:id/favourites", AccountController, :favourites)
	end

	scope [] do
	pipe_through(:authenticated_api)

	post("/accounts/:id/subscribe", AccountController, :subscribe)
	post("/accounts/:id/unsubscribe", AccountController, :unsubscribe)
	end

	post("/accounts/confirmation_resend", AccountController, :confirmation_resend)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)
	get("/accounts/:id/scrobbles", ScrobbleController, :index)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:authenticated_api)

	get("/accounts/verify_credentials", AccountController, :verify_credentials)
	patch("/accounts/update_credentials", AccountController, :update_credentials)

	get("/accounts/relationships", AccountController, :relationships)
	get("/accounts/:id/lists", AccountController, :lists)
	get("/accounts/:id/identity_proofs", AccountController, :identity_proofs)
	get("/endorsements", AccountController, :endorsements)
	get("/blocks", AccountController, :blocks)
	get("/mutes", AccountController, :mutes)

	post("/follows", AccountController, :follow_by_uri)
	post("/accounts/:id/follow", AccountController, :follow)
	post("/accounts/:id/unfollow", AccountController, :unfollow)
	post("/accounts/:id/block", AccountController, :block)
	post("/accounts/:id/unblock", AccountController, :unblock)
	post("/accounts/:id/mute", AccountController, :mute)
	post("/accounts/:id/unmute", AccountController, :unmute)

	get("/apps/verify_credentials", AppController, :verify_credentials)

	get("/conversations", ConversationController, :index)
	post("/conversations/:id/read", ConversationController, :mark_as_read)

	get("/domain_blocks", DomainBlockController, :index)
	post("/domain_blocks", DomainBlockController, :create)
	delete("/domain_blocks", DomainBlockController, :delete)

	get("/filters", FilterController, :index)

	post("/filters", FilterController, :create)
	get("/filters/:id", FilterController, :show)
	put("/filters/:id", FilterController, :update)
	delete("/filters/:id", FilterController, :delete)

	get("/follow_requests", FollowRequestController, :index)
	post("/follow_requests/:id/authorize", FollowRequestController, :authorize)
	post("/follow_requests/:id/reject", FollowRequestController, :reject)

	get("/lists", ListController, :index)
	get("/lists/:id", ListController, :show)
	get("/lists/:id/accounts", ListController, :list_accounts)

	delete("/lists/:id", ListController, :delete)
	post("/lists", ListController, :create)
	put("/lists/:id", ListController, :update)
	post("/lists/:id/accounts", ListController, :add_to_list)
	delete("/lists/:id/accounts", ListController, :remove_from_list)

	get("/markers", MarkerController, :index)
	post("/markers", MarkerController, :upsert)

	post("/media", MediaController, :create)
	get("/media/:id", MediaController, :show)
	put("/media/:id", MediaController, :update)

	get("/notifications", NotificationController, :index)
	get("/notifications/:id", NotificationController, :show)

	post("/notifications/:id/dismiss", NotificationController, :dismiss)
	post("/notifications/clear", NotificationController, :clear)
	delete("/notifications/destroy_multiple", NotificationController, :destroy_multiple)
	# Deprecated: was removed in Mastodon v3, use `/notifications/:id/dismiss` instead
	post("/notifications/dismiss", NotificationController, :dismiss_via_body)

	post("/polls/:id/votes", PollController, :vote)

	post("/reports", ReportController, :create)

	get("/scheduled_statuses", ScheduledActivityController, :index)
	get("/scheduled_statuses/:id", ScheduledActivityController, :show)

	put("/scheduled_statuses/:id", ScheduledActivityController, :update)
	delete("/scheduled_statuses/:id", ScheduledActivityController, :delete)

	# Unlike `GET /api/v1/accounts/:id/favourites`, demands authentication
	get("/favourites", StatusController, :favourites)
	get("/bookmarks", StatusController, :bookmarks)

	post("/statuses", StatusController, :create)
	delete("/statuses/:id", StatusController, :delete)
	post("/statuses/:id/reblog", StatusController, :reblog)
	post("/statuses/:id/unreblog", StatusController, :unreblog)
	post("/statuses/:id/favourite", StatusController, :favourite)
	post("/statuses/:id/unfavourite", StatusController, :unfavourite)
	post("/statuses/:id/pin", StatusController, :pin)
	post("/statuses/:id/unpin", StatusController, :unpin)
	post("/statuses/:id/bookmark", StatusController, :bookmark)
	post("/statuses/:id/unbookmark", StatusController, :unbookmark)
	post("/statuses/:id/mute", StatusController, :mute_conversation)
	post("/statuses/:id/unmute", StatusController, :unmute_conversation)

	post("/push/subscription", SubscriptionController, :create)
	get("/push/subscription", SubscriptionController, :show)
	put("/push/subscription", SubscriptionController, :update)
	delete("/push/subscription", SubscriptionController, :delete)

	get("/suggestions", SuggestionController, :index)

	get("/timelines/home", TimelineController, :home)
	get("/timelines/direct", TimelineController, :direct)
	get("/timelines/list/:list_id", TimelineController, :list)
	end

	scope "/api/web", Pleroma.Web do
	pipe_through(:authenticated_api)

	put("/settings", MastoFEController, :put_settings)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)

	get("/accounts/search", SearchController, :account_search)
	get("/search", SearchController, :search)

	get("/accounts/:id/statuses", AccountController, :statuses)
	get("/accounts/:id/followers", AccountController, :followers)
	get("/accounts/:id/following", AccountController, :following)
	get("/accounts/:id", AccountController, :show)

	post("/accounts", AccountController, :create)

	get("/instance", InstanceController, :show)
	get("/instance/peers", InstanceController, :peers)

	post("/apps", AppController, :create)

	get("/statuses", StatusController, :index)
	get("/statuses/:id", StatusController, :show)
	get("/statuses/:id/context", StatusController, :context)
	get("/statuses/:id/card", StatusController, :card)
	get("/statuses/:id/favourited_by", StatusController, :favourited_by)
	get("/statuses/:id/reblogged_by", StatusController, :reblogged_by)

	get("/custom_emojis", CustomEmojiController, :index)

	get("/trends", MastodonAPIController, :empty_array)

	get("/timelines/public", TimelineController, :public)
	get("/timelines/tag/:tag", TimelineController, :hashtag)

	get("/polls/:id", PollController, :show)
	end

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through(:api)
	get("/search", SearchController, :search2)

	post("/media", MediaController, :create2)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:config)

	get("/help/test", TwitterAPI.UtilController, :help_test)
	post("/help/test", TwitterAPI.UtilController, :help_test)
	get("/statusnet/config", TwitterAPI.UtilController, :config)
	get("/statusnet/version", TwitterAPI.UtilController, :version)
	get("/pleroma/frontend_configurations", TwitterAPI.UtilController, :frontend_configurations)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:api)

	get(
	"/account/confirm_email/:user_id/:token",
	TwitterAPI.Controller,
	:confirm_email,
	as: :confirm_email
	)
	end

	scope "/api" do
	pipe_through(:base_api)

	get("/openapi", OpenApiSpex.Plug.RenderSpec, [])
	end

	scope "/api", Pleroma.Web, as: :authenticated_twitter_api do
	pipe_through(:authenticated_api)

	get("/oauth_tokens", TwitterAPI.Controller, :oauth_tokens)
	delete("/oauth_tokens/:id", TwitterAPI.Controller, :revoke_token)

	post(
	"/qvitter/statuses/notifications/read",
	TwitterAPI.Controller,
	:mark_notifications_as_read
	)
	end

	pipeline :ostatus do
	plug(:accepts, ["html", "xml", "rss", "atom", "activity+json", "json"])
	plug(Pleroma.Plugs.StaticFEPlug)
	end

	pipeline :oembed do
	plug(:accepts, ["json", "xml"])
	end

	scope "/", Pleroma.Web do
	pipe_through([:ostatus, :http_signature])

	get("/objects/:uuid", OStatus.OStatusController, :object)
	get("/activities/:uuid", OStatus.OStatusController, :activity)
	get("/notice/:id", OStatus.OStatusController, :notice)
	get("/notice/:id/embed_player", OStatus.OStatusController, :notice_player)

	+ # Mastodon compatibility routes
	+ get("/users/:nickname/statuses/:id", OStatus.OStatusController, :object)
	+ get("/users/:nickname/statuses/:id/activity", OStatus.OStatusController, :activity)
	+
	get("/users/:nickname/feed", Feed.UserController, :feed, as: :user_feed)
	get("/users/:nickname", Feed.UserController, :feed_redirect, as: :user_feed)

	get("/tags/:tag", Feed.TagController, :feed, as: :tag_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through(:browser)
	get("/mailer/unsubscribe/:token", Mailer.SubscriptionController, :unsubscribe)
	end

	scope "/", Pleroma.Web.ActivityPub do
	# XXX: not really ostatus
	pipe_through(:ostatus)

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	end

	pipeline :ap_service_actor do
	plug(:accepts, ["activity+json", "json"])
	end

	# Server to Server (S2S) AP interactions
	pipeline :activitypub do
	plug(:ap_service_actor)
	plug(:http_signature)
	end

	# Client to Server (C2S) AP interactions
	pipeline :activitypub_client do
	plug(:ap_service_actor)
	plug(:fetch_session)
	plug(:authenticate)
	plug(:after_auth)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through([:activitypub_client])

	get("/api/ap/whoami", ActivityPubController, :whoami)
	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)

	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	post("/api/ap/upload_media", ActivityPubController, :upload_media)

	# The following two are S2S as well, see `ActivityPub.fetch_follow_information_for_user/1`:
	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/inbox", ActivityPubController, :inbox)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :relay)

	scope [] do
	pipe_through(:http_signature)
	post("/inbox", ActivityPubController, :inbox)
	end

	get("/following", ActivityPubController, :relay_following)
	get("/followers", ActivityPubController, :relay_followers)
	end

	scope "/internal/fetch", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :internal_fetch)
	post("/inbox", ActivityPubController, :inbox)
	end

	scope "/.well-known", Pleroma.Web do
	pipe_through(:well_known)

	get("/host-meta", WebFinger.WebFingerController, :host_meta)
	get("/webfinger", WebFinger.WebFingerController, :webfinger)
	get("/nodeinfo", Nodeinfo.NodeinfoController, :schemas)
	end

	scope "/nodeinfo", Pleroma.Web do
	get("/:version", Nodeinfo.NodeinfoController, :nodeinfo)
	end

	scope "/", Pleroma.Web do
	pipe_through(:api)

	get("/web/manifest.json", MastoFEController, :manifest)
	end

	scope "/", Pleroma.Web do
	pipe_through(:mastodon_html)

	get("/web/login", MastodonAPI.AuthController, :login)
	delete("/auth/sign_out", MastodonAPI.AuthController, :logout)

	post("/auth/password", MastodonAPI.AuthController, :password_reset)

	get("/web/*path", MastoFEController, :index)
	end

	scope "/proxy/", Pleroma.Web.MediaProxy do
	get("/:sig/:url", MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxyController, :remote)
	end

	if Pleroma.Config.get(:env) == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

	forward("/mailbox", Plug.Swoosh.MailboxPreview, base_path: "/dev/mailbox")
	end
	end

	# Test-only routes needed to test action dispatching and plug chain execution
	if Pleroma.Config.get(:env) == :test do
	@test_actions [
	:do_oauth_check,
	:fallback_oauth_check,
	:skip_oauth_check,
	:fallback_oauth_skip_publicity_check,
	:skip_oauth_skip_publicity_check,
	:missing_oauth_check_definition
	]

	scope "/test/api", Pleroma.Tests do
	pipe_through(:api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end

	scope "/test/authenticated_api", Pleroma.Tests do
	pipe_through(:authenticated_api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end
	end

	scope "/", Pleroma.Web.MongooseIM do
	get("/user_exists", MongooseIMController, :user_exists)
	get("/check_password", MongooseIMController, :check_password)
	end

	scope "/", Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	get("/api*path", RedirectController, :api_not_implemented)
	get("/*path", RedirectController, :redirector)

	options("/*path", RedirectController, :empty)
	end
	end
	diff --git a/lib/pleroma/workers/cron/clear_oauth_token_worker.ex b/lib/pleroma/workers/cron/clear_oauth_token_worker.ex
	index 341eff054..a4c3b9516 100644
	--- a/lib/pleroma/workers/cron/clear_oauth_token_worker.ex
	+++ b/lib/pleroma/workers/cron/clear_oauth_token_worker.ex
	@@ -1,21 +1,23 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.Cron.ClearOauthTokenWorker do
	@moduledoc """
	The worker to cleanup expired oAuth tokens.
	"""

	use Oban.Worker, queue: "background"

	alias Pleroma.Config
	alias Pleroma.Web.OAuth.Token

	@impl Oban.Worker
	def perform(_opts, _job) do
	if Config.get([:oauth2, :clean_expired_tokens], false) do
	Token.delete_expired_tokens()
	+ else
	+ :ok
	end
	end
	end
	diff --git a/lib/pleroma/workers/cron/digest_emails_worker.ex b/lib/pleroma/workers/cron/digest_emails_worker.ex
	index dd13c3b17..7f09ff3cf 100644
	--- a/lib/pleroma/workers/cron/digest_emails_worker.ex
	+++ b/lib/pleroma/workers/cron/digest_emails_worker.ex
	@@ -1,59 +1,61 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.Cron.DigestEmailsWorker do
	@moduledoc """
	The worker to send digest emails.
	"""

	use Oban.Worker, queue: "digest_emails"

	alias Pleroma.Config
	alias Pleroma.Emails
	alias Pleroma.Repo
	alias Pleroma.User

	import Ecto.Query

	require Logger

	@impl Oban.Worker
	def perform(_opts, _job) do
	config = Config.get([:email_notifications, :digest])

	if config[:active] do
	negative_interval = -Map.fetch!(config, :interval)
	inactivity_threshold = Map.fetch!(config, :inactivity_threshold)
	inactive_users_query = User.list_inactive_users_query(inactivity_threshold)

	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	from(u in inactive_users_query,
	where: fragment(~s(? ->'digest' @> 'true'), u.email_notifications),
	where: not is_nil(u.email),
	where: u.last_digest_emailed_at < datetime_add(^now, ^negative_interval, "day"),
	select: u
	)
	\|> Repo.all()
	\|> send_emails
	+ else
	+ :ok
	end
	end

	def send_emails(users) do
	Enum.each(users, &send_email/1)
	end

	@doc """
	Send digest email to the given user.
	Updates `last_digest_emailed_at` field for the user and returns the updated user.
	"""
	@spec send_email(User.t()) :: User.t()
	def send_email(user) do
	with %Swoosh.Email{} = email <- Emails.UserEmail.digest_email(user) do
	Emails.Mailer.deliver_async(email)
	end

	User.touch_last_digest_emailed_at(user)
	end
	end
	diff --git a/lib/pleroma/workers/cron/new_users_digest_worker.ex b/lib/pleroma/workers/cron/new_users_digest_worker.ex
	index 9bd0a5621..5c816b3fe 100644
	--- a/lib/pleroma/workers/cron/new_users_digest_worker.ex
	+++ b/lib/pleroma/workers/cron/new_users_digest_worker.ex
	@@ -1,61 +1,65 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.Cron.NewUsersDigestWorker do
	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.User

	import Ecto.Query

	use Pleroma.Workers.WorkerHelper, queue: "new_users_digest"

	@impl Oban.Worker
	def perform(_args, _job) do
	if Pleroma.Config.get([Pleroma.Emails.NewUsersDigestEmail, :enabled]) do
	today = NaiveDateTime.utc_now() \|> Timex.beginning_of_day()

	a_day_ago =
	today
	\|> Timex.shift(days: -1)
	\|> Timex.beginning_of_day()

	users_and_statuses =
	%{
	local: true,
	order_by: :inserted_at
	}
	\|> User.Query.build()
	\|> where([u], u.inserted_at >= ^a_day_ago and u.inserted_at < ^today)
	\|> Repo.all()
	\|> Enum.map(fn user ->
	latest_status =
	Activity
	\|> Activity.Queries.by_actor(user.ap_id)
	\|> Activity.Queries.by_type("Create")
	\|> Activity.with_preloaded_object()
	\|> order_by(desc: :inserted_at)
	\|> limit(1)
	\|> Repo.one()

	total_statuses =
	Activity
	\|> Activity.Queries.by_actor(user.ap_id)
	\|> Activity.Queries.by_type("Create")
	\|> Repo.aggregate(:count, :id)

	{user, total_statuses, latest_status}
	end)

	if users_and_statuses != [] do
	%{is_admin: true}
	\|> User.Query.build()
	\|> where([u], not is_nil(u.email))
	\|> Repo.all()
	\|> Enum.map(&Pleroma.Emails.NewUsersDigestEmail.new_users(&1, users_and_statuses))
	\|> Enum.each(&Pleroma.Emails.Mailer.deliver/1)
	+ else
	+ :ok
	end
	+ else
	+ :ok
	end
	end
	end
	diff --git a/lib/pleroma/workers/cron/purge_expired_activities_worker.ex b/lib/pleroma/workers/cron/purge_expired_activities_worker.ex
	index b8953dd7f..84b3b84de 100644
	--- a/lib/pleroma/workers/cron/purge_expired_activities_worker.ex
	+++ b/lib/pleroma/workers/cron/purge_expired_activities_worker.ex
	@@ -1,46 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.Cron.PurgeExpiredActivitiesWorker do
	@moduledoc """
	The worker to purge expired activities.
	"""

	use Oban.Worker, queue: "activity_expiration"

	alias Pleroma.Activity
	alias Pleroma.ActivityExpiration
	alias Pleroma.Config
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	require Logger

	@interval :timer.minutes(1)

	@impl Oban.Worker
	def perform(_opts, _job) do
	if Config.get([ActivityExpiration, :enabled]) do
	Enum.each(ActivityExpiration.due_expirations(@interval), &delete_activity/1)
	+ else
	+ :ok
	end
	end

	def delete_activity(%ActivityExpiration{activity_id: activity_id}) do
	with {:activity, %Activity{} = activity} <-
	{:activity, Activity.get_by_id_with_object(activity_id)},
	{:user, %User{} = user} <- {:user, User.get_by_ap_id(activity.object.data["actor"])} do
	CommonAPI.delete(activity.id, user)
	else
	{:activity, _} ->
	Logger.error(
	"#{__MODULE__} Couldn't delete expired activity: not found activity ##{activity_id}"
	)

	{:user, _} ->
	Logger.error(
	"#{__MODULE__} Couldn't delete expired activity: not found actorof ##{activity_id}"
	)
	end
	end
	end
	diff --git a/test/plugs/authentication_plug_test.exs b/test/plugs/authentication_plug_test.exs
	index 3c70c1747..777ae15ae 100644
	--- a/test/plugs/authentication_plug_test.exs
	+++ b/test/plugs/authentication_plug_test.exs
	@@ -1,124 +1,125 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Plugs.AuthenticationPlugTest do
	use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Plugs.AuthenticationPlug
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Plugs.PlugHelper
	alias Pleroma.User

	import ExUnit.CaptureLog
	import Pleroma.Factory

	setup %{conn: conn} do
	user = %User{
	id: 1,
	name: "dude",
	password_hash: Pbkdf2.hash_pwd_salt("guy")
	}

	conn =
	conn
	\|> assign(:auth_user, user)

	%{user: user, conn: conn}
	end

	test "it does nothing if a user is assigned", %{conn: conn} do
	conn =
	conn
	\|> assign(:user, %User{})

	ret_conn =
	conn
	\|> AuthenticationPlug.call(%{})

	assert ret_conn == conn
	end

	test "with a correct password in the credentials, " <>
	"it assigns the auth_user and marks OAuthScopesPlug as skipped",
	%{conn: conn} do
	conn =
	conn
	\|> assign(:auth_credentials, %{password: "guy"})
	\|> AuthenticationPlug.call(%{})

	assert conn.assigns.user == conn.assigns.auth_user
	assert PlugHelper.plug_skipped?(conn, OAuthScopesPlug)
	end

	test "with a bcrypt hash, it updates to a pkbdf2 hash", %{conn: conn} do
	user = insert(:user, password_hash: Bcrypt.hash_pwd_salt("123"))
	assert "$2" <> _ = user.password_hash

	conn =
	conn
	\|> assign(:auth_user, user)
	\|> assign(:auth_credentials, %{password: "123"})
	\|> AuthenticationPlug.call(%{})

	assert conn.assigns.user.id == conn.assigns.auth_user.id
	assert PlugHelper.plug_skipped?(conn, OAuthScopesPlug)

	user = User.get_by_id(user.id)
	assert "$pbkdf2" <> _ = user.password_hash
	end

	+ @tag :skip_on_mac
	test "with a crypt hash, it updates to a pkbdf2 hash", %{conn: conn} do
	user =
	insert(:user,
	password_hash:
	"$6$9psBWV8gxkGOZWBz$PmfCycChoxeJ3GgGzwvhlgacb9mUoZ.KUXNCssekER4SJ7bOK53uXrHNb2e4i8yPFgSKyzaW9CcmrDXWIEMtD1"
	)

	conn =
	conn
	\|> assign(:auth_user, user)
	\|> assign(:auth_credentials, %{password: "password"})
	\|> AuthenticationPlug.call(%{})

	assert conn.assigns.user.id == conn.assigns.auth_user.id
	assert PlugHelper.plug_skipped?(conn, OAuthScopesPlug)

	user = User.get_by_id(user.id)
	assert "$pbkdf2" <> _ = user.password_hash
	end

	describe "checkpw/2" do
	test "check pbkdf2 hash" do
	hash =
	"$pbkdf2-sha512$160000$loXqbp8GYls43F0i6lEfIw$AY.Ep.2pGe57j2hAPY635sI/6w7l9Q9u9Bp02PkPmF3OrClDtJAI8bCiivPr53OKMF7ph6iHhN68Rom5nEfC2A"

	assert AuthenticationPlug.checkpw("test-password", hash)
	refute AuthenticationPlug.checkpw("test-password1", hash)
	end

	@tag :skip_on_mac
	test "check sha512-crypt hash" do
	hash =
	"$6$9psBWV8gxkGOZWBz$PmfCycChoxeJ3GgGzwvhlgacb9mUoZ.KUXNCssekER4SJ7bOK53uXrHNb2e4i8yPFgSKyzaW9CcmrDXWIEMtD1"

	assert AuthenticationPlug.checkpw("password", hash)
	end

	test "check bcrypt hash" do
	hash = "$2a$10$uyhC/R/zoE1ndwwCtMusK.TLVzkQ/Ugsbqp3uXI.CTTz0gBw.24jS"

	assert AuthenticationPlug.checkpw("password", hash)
	refute AuthenticationPlug.checkpw("password1", hash)
	end

	test "it returns false when hash invalid" do
	hash =
	"psBWV8gxkGOZWBz$PmfCycChoxeJ3GgGzwvhlgacb9mUoZ.KUXNCssekER4SJ7bOK53uXrHNb2e4i8yPFgSKyzaW9CcmrDXWIEMtD1"

	assert capture_log(fn ->
	refute Pleroma.Plugs.AuthenticationPlug.checkpw("password", hash)
	end) =~ "[error] Password hash not recognized"
	end
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_controller_test.exs b/test/web/activity_pub/activity_pub_controller_test.exs
	index c432c90e3..dd2a48a61 100644
	--- a/test/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,1356 +1,1415 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	- import Pleroma.Factory
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Delivery
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	+ alias Pleroma.Web.Endpoint
	alias Pleroma.Workers.ReceiverWorker

	+ import Pleroma.Factory
	+
	+ require Pleroma.Constants
	+
	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :federating], true)

	describe "/relay" do
	setup do: clear_config([:instance, :allow_relay])

	test "with the relay active, it returns the relay user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(200)

	assert res["id"] =~ "/relay"
	end

	test "with the relay disabled, it returns 404", %{conn: conn} do
	Config.put([:instance, :allow_relay], false)

	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	Config.put([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end
	end

	describe "/internal/fetch" do
	test "it returns the internal fetch user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(200)

	assert res["id"] =~ "/fetch"
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	Config.put([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(404)
	end
	end

	describe "/users/:nickname" do
	test "it returns a json representation of the user with accept application/json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/activity+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/ld+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns 404 for remote users", %{
	conn: conn
	} do
	user = insert(:user, local: false, nickname: "remoteuser@example.com")

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}.json")

	assert json_response(conn, 404)
	end

	test "it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == "Not found"
	end

	test "it requires authentication if instance is NOT federating", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	put_req_header(
	conn,
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)

	ensure_federating_or_authenticated(conn, "/users/#{user.nickname}.json", user)
	end
	end

	+ describe "mastodon compatibility routes" do
	+ test "it returns a json representation of the object with accept application/json", %{
	+ conn: conn
	+ } do
	+ {:ok, object} =
	+ %{
	+ "type" => "Note",
	+ "content" => "hey",
	+ "id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	+ "actor" => Endpoint.url() <> "/users/raymoo",
	+ "to" => [Pleroma.Constants.as_public()]
	+ }
	+ \|> Object.create()
	+
	+ conn =
	+ conn
	+ \|> put_req_header("accept", "application/json")
	+ \|> get("/users/raymoo/statuses/999999999")
	+
	+ assert json_response(conn, 200) == ObjectView.render("object.json", %{object: object})
	+ end
	+
	+ test "it returns a json representation of the activity with accept application/json", %{
	+ conn: conn
	+ } do
	+ {:ok, object} =
	+ %{
	+ "type" => "Note",
	+ "content" => "hey",
	+ "id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	+ "actor" => Endpoint.url() <> "/users/raymoo",
	+ "to" => [Pleroma.Constants.as_public()]
	+ }
	+ \|> Object.create()
	+
	+ {:ok, activity, _} =
	+ %{
	+ "id" => object.data["id"] <> "/activity",
	+ "type" => "Create",
	+ "object" => object.data["id"],
	+ "actor" => object.data["actor"],
	+ "to" => object.data["to"]
	+ }
	+ \|> ActivityPub.persist(local: true)
	+
	+ conn =
	+ conn
	+ \|> put_req_header("accept", "application/json")
	+ \|> get("/users/raymoo/statuses/999999999/activity")
	+
	+ assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	+ end
	+ end
	+
	describe "/objects/:uuid" do
	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/activity+json",
	%{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/ld+json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns 404 for non-public messages", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it returns 404 for tombstone objects", %{conn: conn} do
	tombstone = insert(:tombstone)
	uuid = String.split(tombstone.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after object deletion", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Object.delete(note)

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

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

	test "it requires authentication if instance is NOT federating", %{
	conn: conn
	} do
	user = insert(:user)
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn = put_req_header(conn, "accept", "application/activity+json")

	ensure_federating_or_authenticated(conn, "/objects/#{uuid}", user)
	end
	end

	describe "/activities/:uuid" do
	test "it returns a json representation of the activity", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end

	test "it returns 404 for non-public activities", %{conn: conn} do
	activity = insert(:direct_note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after activity deletion", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "cofe"})

	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Activity.delete_all_by_object_ap_id(activity.object.data["id"])

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

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

	test "it requires authentication if instance is NOT federating", %{
	conn: conn
	} do
	user = insert(:user)
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn = put_req_header(conn, "accept", "application/activity+json")

	ensure_federating_or_authenticated(conn, "/activities/#{uuid}", user)
	end
	end

	describe "/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	sender_url = data["actor"]
	Instances.set_consistently_unreachable(sender_url)
	refute Instances.reachable?(sender_url)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_url)
	end

	test "accept follow activity", %{conn: conn} do
	Pleroma.Config.put([:instance, :federating], true)
	relay = Relay.get_actor()

	assert {:ok, %Activity{} = activity} = Relay.follow("https://relay.mastodon.host/actor")

	followed_relay = Pleroma.User.get_by_ap_id("https://relay.mastodon.host/actor")
	relay = refresh_record(relay)

	accept =
	File.read!("test/fixtures/relay/accept-follow.json")
	\|> String.replace("{{ap_id}}", relay.ap_id)
	\|> String.replace("{{activity_id}}", activity.data["id"])

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", accept)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.FollowingRelationship.following?(
	relay,
	followed_relay
	)

	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])
	assert_receive {:mix_shell, :info, ["relay.mastodon.host"]}
	end

	test "without valid signature, " <>
	"it only accepts Create activities and requires enabled federation",
	%{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()
	non_create_data = File.read!("test/fixtures/mastodon-announce.json") \|> Poison.decode!()

	conn = put_req_header(conn, "content-type", "application/activity+json")

	Config.put([:instance, :federating], false)

	conn
	\|> post("/inbox", data)
	\|> json_response(403)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(403)

	Config.put([:instance, :federating], true)

	ret_conn = post(conn, "/inbox", data)
	assert "ok" == json_response(ret_conn, 200)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(400)
	end
	end

	describe "/users/:nickname/inbox" do
	setup do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	[data: data]
	end

	test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
	user = insert(:user)
	data = Map.put(data, "bcc", [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts messages with to as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	Map.put(data, "to", user.ap_id)
	\|> Map.delete("cc")

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts messages with cc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	Map.put(data, "cc", user.ap_id)
	\|> Map.delete("to")

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert user.ap_id in activity.recipients
	end

	test "it accepts messages with bcc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	Map.put(data, "bcc", user.ap_id)
	\|> Map.delete("to")
	\|> Map.delete("cc")

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts announces with to as string instead of array", %{conn: conn} do
	user = insert(:user)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "http://mastodon.example.org/users/admin",
	"id" => "http://mastodon.example.org/users/admin/statuses/19512778738411822/activity",
	"object" => "https://mastodon.social/users/emelie/statuses/101849165031453009",
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => [user.ap_id],
	"type" => "Announce"
	}

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.recipients
	end

	test "it accepts messages from actors that are followed by the user", %{
	conn: conn,
	data: data
	} do
	recipient = insert(:user)
	actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})

	{:ok, recipient} = User.follow(recipient, actor)

	object =
	data["object"]
	\|> Map.put("attributedTo", actor.ap_id)

	data =
	data
	\|> Map.put("actor", actor.ap_id)
	\|> Map.put("object", object)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects reads from other users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(conn, 403)
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
	user = insert(:user)
	data = Map.put(data, "bcc", [user.ap_id])

	sender_host = URI.parse(data["actor"]).host
	Instances.set_consistently_unreachable(sender_host)
	refute Instances.reachable?(sender_host)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_host)
	end

	test "it removes all follower collections but actor's", %{conn: conn} do
	[actor, recipient] = insert_pair(:user)

	data =
	File.read!("test/fixtures/activitypub-client-post-activity.json")
	\|> Poison.decode!()

	object = Map.put(data["object"], "attributedTo", actor.ap_id)

	data =
	data
	\|> Map.put("id", Utils.generate_object_id())
	\|> Map.put("actor", actor.ap_id)
	\|> Map.put("object", object)
	\|> Map.put("cc", [
	recipient.follower_address,
	actor.follower_address
	])
	\|> Map.put("to", [
	recipient.ap_id,
	recipient.follower_address,
	"https://www.w3.org/ns/activitystreams#Public"
	])

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	activity = Activity.get_by_ap_id(data["id"])

	assert activity.id
	assert actor.follower_address in activity.recipients
	assert actor.follower_address in activity.data["cc"]

	refute recipient.follower_address in activity.recipients
	refute recipient.follower_address in activity.data["cc"]
	refute recipient.follower_address in activity.data["to"]
	end

	test "it requires authentication", %{conn: conn} do
	user = insert(:user)
	conn = put_req_header(conn, "accept", "application/activity+json")

	ret_conn = get(conn, "/users/#{user.nickname}/inbox")
	assert json_response(ret_conn, 403)

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

	assert json_response(ret_conn, 200)
	end
	end

	describe "GET /users/:nickname/outbox" do
	test "it returns 200 even if there're no activities", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox")

	result = json_response(conn, 200)
	assert user.ap_id <> "/outbox" == result["id"]
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it returns an announce activity in a collection", %{conn: conn} do
	announce_activity = insert(:announce_activity)
	user = User.get_cached_by_ap_id(announce_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ announce_activity.data["object"]
	end

	test "it requires authentication if instance is NOT federating", %{
	conn: conn
	} do
	user = insert(:user)
	conn = put_req_header(conn, "accept", "application/activity+json")

	ensure_federating_or_authenticated(conn, "/users/#{user.nickname}/outbox", user)
	end
	end

	describe "POST /users/:nickname/outbox (C2S)" do
	setup do
	[
	activity: %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{"type" => "Note", "content" => "AP C2S test"},
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}
	]
	end

	test "it rejects posts from other users / unauthenticated users", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	other_user = insert(:user)
	conn = put_req_header(conn, "content-type", "application/activity+json")

	conn
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)

	conn
	\|> assign(:user, other_user)
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)
	end

	test "it inserts an incoming create activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(result["id"])
	assert result["object"]
	assert %Object{data: object} = Object.normalize(result["object"])
	assert object["content"] == activity["object"]["content"]
	end

	test "it rejects anything beyond 'Note' creations", %{conn: conn, activity: activity} do
	user = insert(:user)

	activity =
	activity
	\|> put_in(["object", "type"], "Benis")

	_result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)
	end

	test "it inserts an incoming sensitive activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	object = Map.put(activity["object"], "sensitive", true)
	activity = Map.put(activity, "object", object)

	response =
	conn
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(response["id"])
	assert response["object"]
	assert %Object{data: response_object} = Object.normalize(response["object"])
	assert response_object["sensitive"] == true
	assert response_object["content"] == activity["object"]["content"]

	representation =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(response["id"])
	\|> json_response(200)

	assert representation["object"]["sensitive"] == true
	end

	test "it rejects an incoming activity with bogus type", %{conn: conn, activity: activity} do
	user = insert(:user)
	activity = Map.put(activity, "type", "BadType")

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)

	assert json_response(conn, 400)
	end

	test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["type"] == "Tombstone"
	end

	test "it rejects delete activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = insert(:user)

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 400)
	end

	test "it increases like count when receiving a like action", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Like",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["like_count"] == 1
	end
	end

	describe "/relay/followers" do
	test "it returns relay followers", %{conn: conn} do
	relay_actor = Relay.get_actor()
	user = insert(:user)
	User.follow(user, relay_actor)

	result =
	conn
	\|> get("/relay/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	Config.put([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/followers")
	\|> json_response(404)
	end
	end

	describe "/relay/following" do
	test "it returns relay following", %{conn: conn} do
	result =
	conn
	\|> get("/relay/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	Config.put([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/following")
	\|> json_response(404)
	end
	end

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user_two)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns a uri if the user has 'hide_followers' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_followers: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{other_user.nickname}/followers?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_followers: true)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = User.get_cached_by_id(user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)
	end
	end

	describe "delivery tracking" do
	test "it tracks a signed object fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed activity fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed object fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end

	test "it tracks a signed activity fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end
	end

	describe "Additional ActivityPub C2S endpoints" do
	test "GET /api/ap/whoami", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")

	user = User.get_cached_by_id(user.id)

	assert UserView.render("user.json", %{user: user}) == json_response(conn, 200)

	conn
	\|> get("/api/ap/whoami")
	\|> json_response(403)
	end

	setup do: clear_config([:media_proxy])
	setup do: clear_config([Pleroma.Upload])

	test "POST /api/ap/upload_media", %{conn: conn} do
	user = insert(:user)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	object =
	conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(:created)

	assert object["name"] == desc
	assert object["type"] == "Document"
	assert object["actor"] == user.ap_id
	assert [%{"href" => object_href, "mediaType" => object_mediatype}] = object["url"]
	assert is_binary(object_href)
	assert object_mediatype == "image/jpeg"

	activity_request = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "AP C2S test, attachment",
	"attachment" => [object]
	},
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}

	activity_response =
	conn
	\|> assign(:user, user)
	\|> post("/users/#{user.nickname}/outbox", activity_request)
	\|> json_response(:created)

	assert activity_response["id"]
	assert activity_response["object"]
	assert activity_response["actor"] == user.ap_id

	assert %Object{data: %{"attachment" => [attachment]}} =
	Object.normalize(activity_response["object"])

	assert attachment["type"] == "Document"
	assert attachment["name"] == desc

	assert [
	%{
	"href" => ^object_href,
	"type" => "Link",
	"mediaType" => ^object_mediatype
	}
	] = attachment["url"]

	# Fails if unauthenticated
	conn
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(403)
	end
	end
	end
	diff --git a/test/web/activity_pub/mrf/steal_emoji_policy_test.exs b/test/web/activity_pub/mrf/steal_emoji_policy_test.exs
	index 8882c8c13..3f8222736 100644
	--- a/test/web/activity_pub/mrf/steal_emoji_policy_test.exs
	+++ b/test/web/activity_pub/mrf/steal_emoji_policy_test.exs
	@@ -1,64 +1,68 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.StealEmojiPolicyTest do
	use Pleroma.DataCase

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

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do
	- clear_config(:mrf_steal_emoji)
	-
	emoji_path = Path.join(Config.get([:instance, :static_dir]), "emoji/stolen")
	File.rm_rf!(emoji_path)
	File.mkdir!(emoji_path)

	Pleroma.Emoji.reload()
	+
	+ on_exit(fn ->
	+ File.rm_rf!(emoji_path)
	+ end)
	+
	+ :ok
	end

	test "does nothing by default" do
	installed_emoji = Pleroma.Emoji.get_all() \|> Enum.map(fn {k, _} -> k end)
	refute "firedfox" in installed_emoji

	message = %{
	"type" => "Create",
	"object" => %{
	"emoji" => [{"firedfox", "https://example.org/emoji/firedfox.png"}],
	"actor" => "https://example.org/users/admin"
	}
	}

	assert {:ok, message} == StealEmojiPolicy.filter(message)

	installed_emoji = Pleroma.Emoji.get_all() \|> Enum.map(fn {k, _} -> k end)
	refute "firedfox" in installed_emoji
	end

	test "Steals emoji on unknown shortcode from allowed remote host" do
	installed_emoji = Pleroma.Emoji.get_all() \|> Enum.map(fn {k, _} -> k end)
	refute "firedfox" in installed_emoji

	message = %{
	"type" => "Create",
	"object" => %{
	"emoji" => [{"firedfox", "https://example.org/emoji/firedfox.png"}],
	"actor" => "https://example.org/users/admin"
	}
	}

	- Config.put([:mrf_steal_emoji, :hosts], ["example.org"])
	- Config.put([:mrf_steal_emoji, :size_limit], 284_468)
	+ clear_config([:mrf_steal_emoji, :hosts], ["example.org"])
	+ clear_config([:mrf_steal_emoji, :size_limit], 284_468)

	assert {:ok, message} == StealEmojiPolicy.filter(message)

	installed_emoji = Pleroma.Emoji.get_all() \|> Enum.map(fn {k, _} -> k end)
	assert "firedfox" in installed_emoji
	end
	end
	diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/controllers/admin_api_controller_test.exs
	similarity index 95%
	rename from test/web/admin_api/admin_api_controller_test.exs
	rename to test/web/admin_api/controllers/admin_api_controller_test.exs
	index 12cb1afd9..321840a8c 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/controllers/admin_api_controller_test.exs
	@@ -1,3866 +1,3717 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	import ExUnit.CaptureLog
	import Mock
	import Pleroma.Factory

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.ConfigDB
	alias Pleroma.HTML
	alias Pleroma.MFA
	alias Pleroma.ModerationLog
	alias Pleroma.Repo
	alias Pleroma.ReportNote
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MediaProxy

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	:ok
	end

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

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

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

	describe "with [:auth, :enforce_oauth_admin_scope_usage]," do
	setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], true)

	test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
	%{admin: admin} do
	user = insert(:user)
	url = "/api/pleroma/admin/users/#{user.nickname}"

	good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
	good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])

	bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
	bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
	bad_token3 = nil

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, 200)
	end

	for good_token <- [good_token1, good_token2, good_token3] do
	conn =
	build_conn()
	\|> assign(:user, nil)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end

	for bad_token <- [bad_token1, bad_token2, bad_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, bad_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end
	end
	end

	describe "unless [:auth, :enforce_oauth_admin_scope_usage]," do
	setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)

	test "GET /api/pleroma/admin/users/:nickname requires " <>
	"read:accounts or admin:read:accounts or broader scope",
	%{admin: admin} do
	user = insert(:user)
	url = "/api/pleroma/admin/users/#{user.nickname}"

	good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
	good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])
	good_token4 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
	good_token5 = insert(:oauth_token, user: admin, scopes: ["read"])

	good_tokens = [good_token1, good_token2, good_token3, good_token4, good_token5]

	bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts:partial"])
	bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
	bad_token3 = nil

	for good_token <- good_tokens do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, 200)
	end

	for good_token <- good_tokens do
	conn =
	build_conn()
	\|> assign(:user, nil)
	\|> assign(:token, good_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end

	for bad_token <- [bad_token1, bad_token2, bad_token3] do
	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, bad_token)
	\|> get(url)

	assert json_response(conn, :forbidden)
	end
	end
	end

	describe "DELETE /api/pleroma/admin/users" do
	test "single user", %{admin: admin, conn: conn} do
	user = insert(:user)
	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _ -> nil end do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")

	ObanHelpers.perform_all()

	assert User.get_by_nickname(user.nickname).deactivated

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user.nickname}"

	assert json_response(conn, 200) == [user.nickname]

	assert called(Pleroma.Web.Federator.publish(:_))
	end
	end

	test "multiple users", %{admin: admin, conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deleted users: @#{user_one.nickname}, @#{user_two.nickname}"

	response = json_response(conn, 200)
	assert response -- [user_one.nickname, user_two.nickname] == []
	end
	end

	describe "/api/pleroma/admin/users" do
	test "Create", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	},
	%{
	"nickname" => "lain2",
	"email" => "lain2@example.org",
	"password" => "test"
	}
	]
	})

	response = json_response(conn, 200) \|> Enum.map(&Map.get(&1, "type"))
	assert response == ["success", "success"]

	log_entry = Repo.one(ModerationLog)

	assert ["lain", "lain2"] -- Enum.map(log_entry.data["subjects"], & &1["nickname"]) == []
	end

	test "Cannot create user with existing email", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	}
	]
	end

	test "Cannot create user with existing nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => user.nickname,
	"email" => "someuser@plerama.social",
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => "someuser@plerama.social",
	"nickname" => user.nickname
	},
	"error" => "nickname has already been taken",
	"type" => "error"
	}
	]
	end

	test "Multiple user creation works in transaction", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"users" => [
	%{
	"nickname" => "newuser",
	"email" => "newuser@pleroma.social",
	"password" => "test"
	},
	%{
	"nickname" => "lain",
	"email" => user.email,
	"password" => "test"
	}
	]
	})

	assert json_response(conn, 409) == [
	%{
	"code" => 409,
	"data" => %{
	"email" => user.email,
	"nickname" => "lain"
	},
	"error" => "email has already been taken",
	"type" => "error"
	},
	%{
	"code" => 409,
	"data" => %{
	"email" => "newuser@pleroma.social",
	"nickname" => "newuser"
	},
	"error" => "",
	"type" => "error"
	}
	]

	assert User.get_by_nickname("newuser") === nil
	end
	end

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

	conn = get(conn, "/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),
	"confirmation_pending" => false
	}

	assert expected == json_response(conn, 200)
	end

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

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")

	- assert "Not found" == json_response(conn, 404)
	+ assert %{"error" => "Not found"} == json_response(conn, 404)
	end
	end

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

	conn
	\|> 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)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
	end
	end

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

	User.follow(follower, user)

	conn
	\|> 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)

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
	end
	end

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

	conn =
	conn
	\|> 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,
	admin: admin,
	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"]

	log_entry = Repo.one(ModerationLog)

	users =
	[user1.nickname, user2.nickname]
	\|> Enum.map(&"@#{&1}")
	\|> Enum.join(", ")

	tags = ["foo", "bar"] \|> Enum.join(", ")

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} added tags: #{tags} to users: #{users}"
	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 %{conn: conn} do
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	conn
	\|> 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,
	admin: admin,
	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"]

	log_entry = Repo.one(ModerationLog)

	users =
	[user1.nickname, user2.nickname]
	\|> Enum.map(&"@#{&1}")
	\|> Enum.join(", ")

	tags = ["x", "z"] \|> Enum.join(", ")

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} removed tags: #{tags} from users: #{users}"
	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", %{admin: admin, conn: conn} do
	conn =
	conn
	\|> 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", %{admin: admin, conn: conn} do
	user = insert(:user)

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

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

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{user.nickname} admin"
	end

	test "/:right POST, can add to a permission group (multiple)", %{admin: admin, conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/permission_group/admin", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

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

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} made @#{user_one.nickname}, @#{user_two.nickname} admin"
	end

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

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

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

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} revoked admin role from @#{user.nickname}"
	end

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

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/permission_group/admin", %{
	nicknames: [user_one.nickname, user_two.nickname]
	})

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

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} revoked admin role from @#{user_one.nickname}, @#{
	user_two.nickname
	}"
	end
	end

	describe "POST /api/pleroma/admin/email_invite, with valid config" do
	setup do: clear_config([:instance, :registrations_open], false)
	setup do: clear_config([:instance, :invites_enabled], true)

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

	conn =
	post(
	conn,
	"/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
	)

	assert json_response(conn, :no_content)

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

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

	email =
	Pleroma.Emails.UserEmail.user_invitation_email(
	admin,
	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" do
	non_admin_user = insert(:user)
	token = insert(:oauth_token, user: non_admin_user)

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

	assert json_response(conn, :forbidden)
	end

	test "email with +", %{conn: conn, admin: admin} do
	recipient_email = "foo+bar@baz.com"

	conn
	\|> put_req_header("content-type", "application/json;charset=utf-8")
	\|> post("/api/pleroma/admin/users/email_invite", %{email: recipient_email})
	\|> json_response(:no_content)

	token_record =
	Pleroma.UserInviteToken
	\|> Repo.all()
	\|> List.last()

	assert token_record
	refute token_record.used

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

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

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

	describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
	setup do: clear_config([:instance, :registrations_open])
	setup do: clear_config([:instance, :invites_enabled])

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

	conn = post(conn, "/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :bad_request) ==
	- "To send invites you need to set the `invites_enabled` option to true."
	+ %{
	+ "error" =>
	+ "To send invites you need to set the `invites_enabled` option to true."
	+ }
	end

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

	conn = post(conn, "/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :bad_request) ==
	- "To send invites you need to set the `registrations_open` option to false."
	+ %{
	+ "error" =>
	+ "To send invites you need to set the `registrations_open` option to false."
	+ }
	end
	end

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

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

	resp = json_response(conn, 200)

	assert Regex.match?(~r/(http:\/\/\|https:\/\/)/, resp["link"])
	end

	describe "GET /api/pleroma/admin/users" do
	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.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),
	"confirmation_pending" => false
	},
	%{
	"deactivated" => user.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),
	"confirmation_pending" => false
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

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

	test "pagination works correctly with service users", %{conn: conn} do
	service1 = insert(:user, ap_id: Web.base_url() <> "/relay")
	service2 = insert(:user, ap_id: Web.base_url() <> "/internal/fetch")
	insert_list(25, :user)

	assert %{"count" => 26, "page_size" => 10, "users" => users1} =
	conn
	\|> get("/api/pleroma/admin/users?page=1&filters=", %{page_size: "10"})
	\|> json_response(200)

	assert Enum.count(users1) == 10
	assert service1 not in [users1]
	assert service2 not in [users1]

	assert %{"count" => 26, "page_size" => 10, "users" => users2} =
	conn
	\|> get("/api/pleroma/admin/users?page=2&filters=", %{page_size: "10"})
	\|> json_response(200)

	assert Enum.count(users2) == 10
	assert service1 not in [users2]
	assert service2 not in [users2]

	assert %{"count" => 26, "page_size" => 10, "users" => users3} =
	conn
	\|> get("/api/pleroma/admin/users?page=3&filters=", %{page_size: "10"})
	\|> json_response(200)

	assert Enum.count(users3) == 6
	assert service1 not in [users3]
	assert service2 not in [users3]
	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.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),
	"confirmation_pending" => false
	}
	]
	}
	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.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),
	"confirmation_pending" => false
	}
	]
	}
	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.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),
	"confirmation_pending" => false
	}
	]
	}
	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.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),
	"confirmation_pending" => false
	}
	]
	}
	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.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),
	"confirmation_pending" => false
	}
	]
	}
	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.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),
	"confirmation_pending" => false
	}
	]
	}

	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.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),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "only local users" do
	admin = insert(:user, is_admin: true, nickname: "john")
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob")

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

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

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.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),
	"confirmation_pending" => false
	}
	]
	}
	end

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

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

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

	users =
	[
	%{
	"deactivated" => user.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),
	"confirmation_pending" => false
	},
	%{
	"deactivated" => admin.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),
	"confirmation_pending" => false
	},
	%{
	"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),
	"confirmation_pending" => false
	}
	]
	\|> 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, 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),
	"confirmation_pending" => false
	},
	%{
	"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),
	"confirmation_pending" => false
	}
	]
	\|> 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, 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),
	"confirmation_pending" => false
	}
	]
	}
	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),
	"confirmation_pending" => false
	},
	%{
	"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),
	"confirmation_pending" => false
	}
	]
	\|> 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", is_admin: true)
	token = insert(:oauth_admin_token, user: admin)
	user = insert(:user, nickname: "bob", local: false, deactivated: true)

	insert(:user, nickname: "ken", local: true, deactivated: true)
	insert(:user, nickname: "bobb", local: false, deactivated: false)

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

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.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),
	"confirmation_pending" => false
	}
	]
	}
	end

	test "it omits relay user", %{admin: admin, conn: conn} do
	assert %User{} = Relay.get_actor()

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

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => admin.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),
	"confirmation_pending" => false
	}
	]
	}
	end
	end

	test "PATCH /api/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
	user_one = insert(:user, deactivated: true)
	user_two = insert(:user, deactivated: true)

	conn =
	patch(
	conn,
	"/api/pleroma/admin/users/activate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response(conn, 200)
	assert Enum.map(response["users"], & &1["deactivated"]) == [false, false]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

	test "PATCH /api/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
	user_one = insert(:user, deactivated: false)
	user_two = insert(:user, deactivated: false)

	conn =
	patch(
	conn,
	"/api/pleroma/admin/users/deactivate",
	%{nicknames: [user_one.nickname, user_two.nickname]}
	)

	response = json_response(conn, 200)
	assert Enum.map(response["users"], & &1["deactivated"]) == [true, true]

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
	end

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

	conn = patch(conn, "/api/pleroma/admin/users/#{user.nickname}/toggle_activation")

	assert json_response(conn, 200) ==
	%{
	"deactivated" => !user.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),
	"confirmation_pending" => false
	}

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} deactivated users: @#{user.nickname}"
	end

	describe "PUT disable_mfa" do
	test "returns 200 and disable 2fa", %{conn: conn} do
	user =
	insert(:user,
	multi_factor_authentication_settings: %MFA.Settings{
	enabled: true,
	totp: %MFA.Settings.TOTP{secret: "otp_secret", confirmed: true}
	}
	)

	response =
	conn
	\|> put("/api/pleroma/admin/users/disable_mfa", %{nickname: user.nickname})
	\|> json_response(200)

	assert response == user.nickname
	mfa_settings = refresh_record(user).multi_factor_authentication_settings

	refute mfa_settings.enabled
	refute mfa_settings.totp.confirmed
	end

	test "returns 404 if user not found", %{conn: conn} do
	response =
	conn
	\|> put("/api/pleroma/admin/users/disable_mfa", %{nickname: "nickname"})
	\|> json_response(404)

	- assert response == "Not found"
	+ assert response == %{"error" => "Not found"}
	end
	end

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

	invite_json = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(invite_json["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 =
	post(conn, "/api/pleroma/admin/users/invite_token", %{
	"expires_at" => Date.to_string(Date.utc_today())
	})

	invite_json = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(invite_json["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 = post(conn, "/api/pleroma/admin/users/invite_token", %{"max_use" => 150})

	invite_json = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(invite_json["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 =
	post(conn, "/api/pleroma/admin/users/invite_token", %{
	"max_use" => 150,
	"expires_at" => Date.to_string(Date.utc_today())
	})

	invite_json = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(invite_json["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
	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", %{conn: conn} do
	{:ok, invite} = UserInviteToken.create_invite()

	conn = post(conn, "/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

	test "with invalid token", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})

	- assert json_response(conn, :not_found) == "Not found"
	+ assert json_response(conn, :not_found) == %{"error" => "Not found"}
	end
	end

	describe "GET /api/pleroma/admin/reports/:id" do
	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"
	+ assert json_response(conn, :not_found) == %{"error" => "Not found"}
	end
	end

	describe "PATCH /api/pleroma/admin/reports" do
	setup 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]
	})

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

	%{
	id: report_id,
	second_report_id: second_report_id
	}
	end

	test "requires admin:write:reports scope", %{conn: conn, id: id, admin: admin} do
	read_token = insert(:oauth_token, user: admin, scopes: ["admin:read"])
	write_token = insert(:oauth_token, user: admin, scopes: ["admin:write:reports"])

	response =
	conn
	\|> assign(:token, read_token)
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [%{"state" => "resolved", "id" => id}]
	})
	\|> json_response(403)

	assert response == %{
	"error" => "Insufficient permissions: admin:write:reports."
	}

	conn
	\|> assign(:token, write_token)
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [%{"state" => "resolved", "id" => id}]
	})
	\|> json_response(:no_content)
	end

	test "mark report as resolved", %{conn: conn, id: id, admin: admin} do
	conn
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "resolved", "id" => id}
	]
	})
	\|> json_response(:no_content)

	activity = Activity.get_by_id(id)
	assert activity.data["state"] == "resolved"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated report ##{id} with 'resolved' state"
	end

	test "closes report", %{conn: conn, id: id, admin: admin} do
	conn
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "closed", "id" => id}
	]
	})
	\|> json_response(:no_content)

	activity = Activity.get_by_id(id)
	assert activity.data["state"] == "closed"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} updated report ##{id} with 'closed' state"
	end

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

	assert hd(json_response(conn, :bad_request))["error"] == "Unsupported state"
	end

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

	assert hd(json_response(conn, :bad_request))["error"] == "not_found"
	end

	test "updates state of multiple reports", %{
	conn: conn,
	id: id,
	admin: admin,
	second_report_id: second_report_id
	} do
	conn
	\|> patch("/api/pleroma/admin/reports", %{
	"reports" => [
	%{"state" => "resolved", "id" => id},
	%{"state" => "closed", "id" => second_report_id}
	]
	})
	\|> json_response(:no_content)

	activity = Activity.get_by_id(id)
	second_activity = Activity.get_by_id(second_report_id)
	assert activity.data["state"] == "resolved"
	assert second_activity.data["state"] == "closed"

	[first_log_entry, second_log_entry] = Repo.all(ModerationLog)

	assert ModerationLog.get_log_entry_message(first_log_entry) ==
	"@#{admin.nickname} updated report ##{id} with 'resolved' state"

	assert ModerationLog.get_log_entry_message(second_log_entry) ==
	"@#{admin.nickname} updated report ##{second_report_id} with 'closed' state"
	end
	end

	describe "GET /api/pleroma/admin/reports" do
	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"])
	assert response["total"] == 0
	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

	assert response["total"] == 1
	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

	assert response["total"] == 1

	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

	assert response["total"] == 1

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

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

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

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

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

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

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

	- describe "GET /api/pleroma/admin/statuses/:id" do
	- test "not found", %{conn: conn} do
	- assert conn
	- \|> get("/api/pleroma/admin/statuses/not_found")
	- \|> json_response(:not_found)
	- end
	-
	- test "shows activity", %{conn: conn} do
	- activity = insert(:note_activity)
	-
	- response =
	- conn
	- \|> get("/api/pleroma/admin/statuses/#{activity.id}")
	- \|> json_response(200)
	-
	- assert response["id"] == activity.id
	- end
	- end
	-
	- describe "PUT /api/pleroma/admin/statuses/:id" do
	- setup do
	- activity = insert(:note_activity)
	-
	- %{id: activity.id}
	- end
	-
	- test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
	- response =
	- conn
	- \|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
	- \|> json_response(:ok)
	-
	- assert response["sensitive"]
	-
	- log_entry = Repo.one(ModerationLog)
	-
	- assert ModerationLog.get_log_entry_message(log_entry) ==
	- "@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"
	-
	- 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, admin: admin} do
	- response =
	- conn
	- \|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "public"})
	- \|> json_response(:ok)
	-
	- assert response["visibility"] == "public"
	-
	- log_entry = Repo.one(ModerationLog)
	-
	- assert ModerationLog.get_log_entry_message(log_entry) ==
	- "@#{admin.nickname} updated status ##{id}, set 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 = put(conn, "/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 do
	- activity = insert(:note_activity)
	-
	- %{id: activity.id}
	- end
	-
	- test "deletes status", %{conn: conn, id: id, admin: admin} do
	- conn
	- \|> delete("/api/pleroma/admin/statuses/#{id}")
	- \|> json_response(:ok)
	-
	- refute Activity.get_by_id(id)
	-
	- log_entry = Repo.one(ModerationLog)
	-
	- assert ModerationLog.get_log_entry_message(log_entry) ==
	- "@#{admin.nickname} deleted status ##{id}"
	- end
	-
	- test "returns 404 when the status does not exist", %{conn: conn} do
	- conn = delete(conn, "/api/pleroma/admin/statuses/test")
	-
	- assert json_response(conn, :not_found) == "Not found"
	- end
	- end
	-
	describe "GET /api/pleroma/admin/config" do
	setup do: clear_config(:configurable_from_database, true)

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

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

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

	conn = get(conn, "/api/pleroma/admin/config", %{"only_db" => true})

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

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

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

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

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

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

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

	config3 =
	insert(:config,
	value: ConfigDB.to_binary(k1: :v1, k2: :v2)
	)

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

	assert length(configs) > 3

	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	group == ":pleroma" and key in [config1.key, config2.key, config3.key]
	end)

	assert length(received_configs) == 3

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

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	assert db in [[config1.key], [config2.key], db_keys]

	assert value in [
	ConfigDB.from_binary_with_convert(config1.value),
	ConfigDB.from_binary_with_convert(config2.value),
	ConfigDB.from_binary_with_convert(config3.value)
	]
	end)
	end

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

	config2 =
	insert(:config,
	key: ":assets",
	value: ConfigDB.to_binary(mascots: [a: 1, b: 2], key: [a: 1])
	)

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

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

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

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

	assert emoji_val[:groups] == [a: 1, b: 2]
	assert assets_val[:mascots] == [a: 1, b: 2]
	end
	end

	test "POST /api/pleroma/admin/config error", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/config", %{"configs" => []})

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

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

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

	setup do: clear_config(:configurable_from_database, true)

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

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

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

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

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

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

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

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

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

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

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: ":quack",
	key: ":level",
	value: ":info"
	},
	%{
	group: ":quack",
	key: ":meta",
	value: [":none"]
	},
	%{
	group: ":quack",
	key: ":webhook_url",
	value: "https://hooks.slack.com/services/KEY"
	}
	]
	})

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

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

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

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: config.group, key: config.key, value: [%{"tuple" => [":key3", 3]}]}
	]
	})

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

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

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

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

	assert configs["need_reboot"]

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

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

	assert configs["need_reboot"] == false
	end

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

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

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

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

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

	assert configs["need_reboot"] == false
	end

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

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: config.group,
	key: config.key,
	value: [
	%{"tuple" => [":key3", 3]},
	%{
	"tuple" => [
	":key2",
	[
	%{"tuple" => [":k2", 1]},
	%{"tuple" => [":k3", 3]}
	]
	]
	}
	]
	}
	]
	})

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

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

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

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

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

	config =
	insert(:config,
	group: ":logger",
	key: ":backends",
	value: :erlang.term_to_binary([])
	)

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

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

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: config.group,
	key: config.key,
	value: [":console"]
	}
	]
	})

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

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

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

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: config.group, key: config.key, value: "Tesla.Adapter.Httpc"}
	]
	})

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

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

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

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

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => config1.key,
	"value" => "another_value",
	"db" => [":keyaa1"]
	},
	%{
	"group" => ":pleroma",
	"key" => config2.key,
	"value" => "another_value",
	"db" => [":keyaa2"]
	}
	]
	}

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

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> assign(:token, token)
	\|> post("/api/pleroma/admin/config", %{
	configs: [
	%{group: config2.group, key: config2.key, delete: true},
	%{
	group: ":ueberauth",
	key: "Ueberauth",
	delete: true
	}
	]
	})

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

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

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

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

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]},
	%{"tuple" => [":regex1", "~r/https:\\/\\/example.com/"]},
	%{"tuple" => [":regex2", "~r/https:\\/\\/example.com/u"]},
	%{"tuple" => [":regex3", "~r/https:\\/\\/example.com/i"]},
	%{"tuple" => [":regex4", "~r/https:\\/\\/example.com/s"]},
	%{"tuple" => [":name", "Pleroma"]}
	],
	"db" => [
	":enabled",
	":method",
	":seconds_valid",
	":path",
	":key1",
	":partial_chain",
	":regex1",
	":regex2",
	":regex3",
	":regex4",
	":name"
	]
	}
	]
	}
	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" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => ":pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	],
	"db" => [":http"]
	}
	]
	}
	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
	}
	}
	]
	}
	],
	"db" => [":key2", ":key3"]
	}
	]
	}
	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"},
	"db" => [":key1"]
	}
	]
	}
	end

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

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

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

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: config.group,
	key: config.key,
	subkeys: [":subkey1", ":subkey3"],
	delete: true
	}
	]
	})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	refute Restarter.Pleroma.need_reboot?()
	end
	end

	test "need_reboot flag", %{conn: conn} do
	assert conn
	\|> get("/api/pleroma/admin/need_reboot")
	\|> json_response(200) == %{"need_reboot" => false}

	Restarter.Pleroma.need_reboot()

	assert conn
	\|> get("/api/pleroma/admin/need_reboot")
	\|> json_response(200) == %{"need_reboot" => true}

	on_exit(fn -> Restarter.Pleroma.refresh() end)
	end

	- describe "GET /api/pleroma/admin/statuses" do
	- test "returns all public and unlisted statuses", %{conn: conn, admin: admin} do
	- blocked = insert(:user)
	- user = insert(:user)
	- User.block(admin, blocked)
	-
	- {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
	-
	- {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
	- {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
	- {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
	- {:ok, _} = CommonAPI.post(blocked, %{status: ".", visibility: "public"})
	-
	- response =
	- conn
	- \|> get("/api/pleroma/admin/statuses")
	- \|> json_response(200)
	-
	- refute "private" in Enum.map(response, & &1["visibility"])
	- assert length(response) == 3
	- end
	-
	- test "returns only local statuses with local_only on", %{conn: conn} do
	- user = insert(:user)
	- remote_user = insert(:user, local: false, nickname: "archaeme@archae.me")
	- insert(:note_activity, user: user, local: true)
	- insert(:note_activity, user: remote_user, local: false)
	-
	- response =
	- conn
	- \|> get("/api/pleroma/admin/statuses?local_only=true")
	- \|> json_response(200)
	-
	- assert length(response) == 1
	- end
	-
	- test "returns private and direct statuses with godmode on", %{conn: conn, admin: admin} do
	- user = insert(:user)
	-
	- {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
	-
	- {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
	- {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
	- conn = get(conn, "/api/pleroma/admin/statuses?godmode=true")
	- assert json_response(conn, 200) \|> length() == 3
	- end
	- end
	-
	describe "GET /api/pleroma/admin/users/:nickname/statuses" do
	setup do
	user = insert(:user)

	date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) \|> DateTime.from_unix!()
	date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) \|> DateTime.from_unix!()
	date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) \|> DateTime.from_unix!()

	insert(:note_activity, user: user, published: date1)
	insert(:note_activity, user: user, published: date2)
	insert(:note_activity, user: user, published: date3)

	%{user: user}
	end

	test "renders user's statuses", %{conn: conn, user: user} do
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")

	assert json_response(conn, 200) \|> length() == 3
	end

	test "renders user's statuses with a limit", %{conn: conn, user: user} do
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")

	assert json_response(conn, 200) \|> length() == 2
	end

	test "doesn't return private statuses by default", %{conn: conn, user: user} do
	{:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})

	{:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")

	assert json_response(conn, 200) \|> length() == 4
	end

	test "returns private statuses with godmode on", %{conn: conn, user: user} do
	{:ok, _private_status} = CommonAPI.post(user, %{status: "private", visibility: "private"})

	{:ok, _public_status} = CommonAPI.post(user, %{status: "public", visibility: "public"})

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")

	assert json_response(conn, 200) \|> length() == 5
	end

	test "excludes reblogs by default", %{conn: conn, user: user} do
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "."})
	{:ok, %Activity{}} = CommonAPI.repeat(activity.id, other_user)

	conn_res = get(conn, "/api/pleroma/admin/users/#{other_user.nickname}/statuses")
	assert json_response(conn_res, 200) \|> length() == 0

	conn_res =
	get(conn, "/api/pleroma/admin/users/#{other_user.nickname}/statuses?with_reblogs=true")

	assert json_response(conn_res, 200) \|> length() == 1
	end
	end

	describe "GET /api/pleroma/admin/moderation_log" do
	setup do
	moderator = insert(:user, is_moderator: true)

	%{moderator: moderator}
	end

	test "returns the log", %{conn: conn, admin: admin} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
	})

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

	response = json_response(conn, 200)
	[first_entry, second_entry] = response["items"]

	assert response["total"] == 2
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"

	assert second_entry["data"]["action"] == "relay_follow"

	assert second_entry["message"] ==
	"@#{admin.nickname} followed relay: https://example.org/relay"
	end

	test "returns the log with pagination", %{conn: conn, admin: admin} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-15 15:47:06.597036], :second)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.truncate(~N[2017-08-16 15:47:06.597036], :second)
	})

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

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 2
	assert response1["items"] \|> length() == 1
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"

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

	response2 = json_response(conn2, 200)
	[second_entry] = response2["items"]

	assert response2["total"] == 2
	assert response2["items"] \|> length() == 1
	assert second_entry["data"]["action"] == "relay_follow"

	assert second_entry["message"] ==
	"@#{admin.nickname} followed relay: https://example.org/relay"
	end

	test "filters log by date", %{conn: conn, admin: admin} do
	first_date = "2017-08-15T15:47:06Z"
	second_date = "2017-08-20T15:47:06Z"

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.from_iso8601!(first_date)
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	},
	inserted_at: NaiveDateTime.from_iso8601!(second_date)
	})

	conn1 =
	get(
	conn,
	"/api/pleroma/admin/moderation_log?start_date=#{second_date}"
	)

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1
	assert first_entry["data"]["action"] == "relay_unfollow"

	assert first_entry["message"] ==
	"@#{admin.nickname} unfollowed relay: https://example.org/relay"
	end

	test "returns log filtered by user", %{conn: conn, admin: admin, moderator: moderator} do
	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => admin.id,
	"nickname" => admin.nickname,
	"type" => "user"
	},
	action: "relay_follow",
	target: "https://example.org/relay"
	}
	})

	Repo.insert(%ModerationLog{
	data: %{
	actor: %{
	"id" => moderator.id,
	"nickname" => moderator.nickname,
	"type" => "user"
	},
	action: "relay_unfollow",
	target: "https://example.org/relay"
	}
	})

	conn1 = get(conn, "/api/pleroma/admin/moderation_log?user_id=#{moderator.id}")

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1
	assert get_in(first_entry, ["data", "actor", "id"]) == moderator.id
	end

	test "returns log filtered by search", %{conn: conn, moderator: moderator} do
	ModerationLog.insert_log(%{
	actor: moderator,
	action: "relay_follow",
	target: "https://example.org/relay"
	})

	ModerationLog.insert_log(%{
	actor: moderator,
	action: "relay_unfollow",
	target: "https://example.org/relay"
	})

	conn1 = get(conn, "/api/pleroma/admin/moderation_log?search=unfo")

	response1 = json_response(conn1, 200)
	[first_entry] = response1["items"]

	assert response1["total"] == 1

	assert get_in(first_entry, ["data", "message"]) ==
	"@#{moderator.nickname} unfollowed relay: https://example.org/relay"
	end
	end

	describe "GET /users/:nickname/credentials" do
	test "gets the user credentials", %{conn: conn} do
	user = insert(:user)
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials")

	response = assert json_response(conn, 200)
	assert response["email"] == user.email
	end

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

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

	assert json_response(conn, :forbidden)
	end
	end

	describe "PATCH /users/:nickname/credentials" do
	test "changes password and email", %{conn: conn, admin: admin} do
	user = insert(:user)
	assert user.password_reset_pending == false

	conn =
	patch(conn, "/api/pleroma/admin/users/#{user.nickname}/credentials", %{
	"password" => "new_password",
	"email" => "new_email@example.com",
	"name" => "new_name"
	})

	assert json_response(conn, 200) == %{"status" => "success"}

	ObanHelpers.perform_all()

	updated_user = User.get_by_id(user.id)

	assert updated_user.email == "new_email@example.com"
	assert updated_user.name == "new_name"
	assert updated_user.password_hash != user.password_hash
	assert updated_user.password_reset_pending == true

	[log_entry2, log_entry1] = ModerationLog \|> Repo.all() \|> Enum.sort()

	assert ModerationLog.get_log_entry_message(log_entry1) ==
	"@#{admin.nickname} updated users: @#{user.nickname}"

	assert ModerationLog.get_log_entry_message(log_entry2) ==
	"@#{admin.nickname} forced password reset for users: @#{user.nickname}"
	end

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

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> patch("/api/pleroma/admin/users/#{user.nickname}/credentials", %{
	"password" => "new_password",
	"email" => "new_email@example.com",
	"name" => "new_name"
	})

	assert json_response(conn, :forbidden)
	end
	end

	describe "PATCH /users/:nickname/force_password_reset" do
	test "sets password_reset_pending to true", %{conn: conn} do
	user = insert(:user)
	assert user.password_reset_pending == false

	conn =
	patch(conn, "/api/pleroma/admin/users/force_password_reset", %{nicknames: [user.nickname]})

	assert json_response(conn, 204) == ""

	ObanHelpers.perform_all()

	assert User.get_by_id(user.id).password_reset_pending == true
	end
	end

	describe "relays" do
	test "POST /relay", %{conn: conn, admin: admin} do
	conn =
	post(conn, "/api/pleroma/admin/relay", %{
	relay_url: "http://mastodon.example.org/users/admin"
	})

	assert json_response(conn, 200) == "http://mastodon.example.org/users/admin"

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} followed relay: http://mastodon.example.org/users/admin"
	end

	test "GET /relay", %{conn: conn} do
	relay_user = Pleroma.Web.ActivityPub.Relay.get_actor()

	["http://mastodon.example.org/users/admin", "https://mstdn.io/users/mayuutann"]
	\|> Enum.each(fn ap_id ->
	{:ok, user} = User.get_or_fetch_by_ap_id(ap_id)
	User.follow(relay_user, user)
	end)

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

	assert json_response(conn, 200)["relays"] -- ["mastodon.example.org", "mstdn.io"] == []
	end

	test "DELETE /relay", %{conn: conn, admin: admin} do
	post(conn, "/api/pleroma/admin/relay", %{
	relay_url: "http://mastodon.example.org/users/admin"
	})

	conn =
	delete(conn, "/api/pleroma/admin/relay", %{
	relay_url: "http://mastodon.example.org/users/admin"
	})

	assert json_response(conn, 200) == "http://mastodon.example.org/users/admin"

	[log_entry_one, log_entry_two] = Repo.all(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry_one) ==
	"@#{admin.nickname} followed relay: http://mastodon.example.org/users/admin"

	assert ModerationLog.get_log_entry_message(log_entry_two) ==
	"@#{admin.nickname} unfollowed relay: http://mastodon.example.org/users/admin"
	end
	end

	describe "instances" do
	test "GET /instances/:instance/statuses", %{conn: conn} do
	user = insert(:user, local: false, nickname: "archaeme@archae.me")
	user2 = insert(:user, local: false, nickname: "test@test.com")
	insert_pair(:note_activity, user: user)
	activity = insert(:note_activity, user: user2)

	ret_conn = get(conn, "/api/pleroma/admin/instances/archae.me/statuses")

	response = json_response(ret_conn, 200)

	assert length(response) == 2

	ret_conn = get(conn, "/api/pleroma/admin/instances/test.com/statuses")

	response = json_response(ret_conn, 200)

	assert length(response) == 1

	ret_conn = get(conn, "/api/pleroma/admin/instances/nonexistent.com/statuses")

	response = json_response(ret_conn, 200)

	assert Enum.empty?(response)

	CommonAPI.repeat(activity.id, user)

	ret_conn = get(conn, "/api/pleroma/admin/instances/archae.me/statuses")
	response = json_response(ret_conn, 200)
	assert length(response) == 2

	ret_conn = get(conn, "/api/pleroma/admin/instances/archae.me/statuses?with_reblogs=true")
	response = json_response(ret_conn, 200)
	assert length(response) == 3
	end
	end

	describe "PATCH /confirm_email" do
	test "it confirms emails of two users", %{conn: conn, admin: admin} do
	[first_user, second_user] = insert_pair(:user, confirmation_pending: true)

	assert first_user.confirmation_pending == true
	assert second_user.confirmation_pending == true

	ret_conn =
	patch(conn, "/api/pleroma/admin/users/confirm_email", %{
	nicknames: [
	first_user.nickname,
	second_user.nickname
	]
	})

	assert ret_conn.status == 200

	assert first_user.confirmation_pending == true
	assert second_user.confirmation_pending == true

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} confirmed email for users: @#{first_user.nickname}, @#{
	second_user.nickname
	}"
	end
	end

	describe "PATCH /resend_confirmation_email" do
	test "it resend emails for two users", %{conn: conn, admin: admin} do
	[first_user, second_user] = insert_pair(:user, confirmation_pending: true)

	ret_conn =
	patch(conn, "/api/pleroma/admin/users/resend_confirmation_email", %{
	nicknames: [
	first_user.nickname,
	second_user.nickname
	]
	})

	assert ret_conn.status == 200

	log_entry = Repo.one(ModerationLog)

	assert ModerationLog.get_log_entry_message(log_entry) ==
	"@#{admin.nickname} re-sent confirmation email for users: @#{first_user.nickname}, @#{
	second_user.nickname
	}"
	end
	end

	describe "POST /reports/:id/notes" do
	setup %{conn: conn, admin: admin} 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]
	})

	post(conn, "/api/pleroma/admin/reports/#{report_id}/notes", %{
	content: "this is disgusting!"
	})

	post(conn, "/api/pleroma/admin/reports/#{report_id}/notes", %{
	content: "this is disgusting2!"
	})

	%{
	admin_id: admin.id,
	report_id: report_id
	}
	end

	test "it creates report note", %{admin_id: admin_id, report_id: report_id} do
	[note, _] = Repo.all(ReportNote)

	assert %{
	activity_id: ^report_id,
	content: "this is disgusting!",
	user_id: ^admin_id
	} = note
	end

	test "it returns reports with notes", %{conn: conn, admin: admin} do
	conn = get(conn, "/api/pleroma/admin/reports")

	response = json_response(conn, 200)
	notes = hd(response["reports"])["notes"]
	[note, _] = notes

	assert note["user"]["nickname"] == admin.nickname
	assert note["content"] == "this is disgusting!"
	assert note["created_at"]
	assert response["total"] == 1
	end

	test "it deletes the note", %{conn: conn, report_id: report_id} do
	assert ReportNote \|> Repo.all() \|> length() == 2

	[note, _] = Repo.all(ReportNote)

	delete(conn, "/api/pleroma/admin/reports/#{report_id}/notes/#{note.id}")

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

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

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

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

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

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

	admin = insert(:user, is_admin: true)

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

	children = json_response(conn, 200)

	assert length(children) == 4

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

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

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

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

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

	describe "/api/pleroma/admin/stats" do
	test "status visibility count", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	user = insert(:user)
	CommonAPI.post(user, %{visibility: "public", status: "hey"})
	CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})
	CommonAPI.post(user, %{visibility: "unlisted", status: "hey"})

	response =
	conn
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/stats")
	\|> json_response(200)

	assert %{"direct" => 0, "private" => 0, "public" => 1, "unlisted" => 2} =
	response["status_visibility"]
	end
	end

	describe "POST /api/pleroma/admin/oauth_app" do
	test "errors", %{conn: conn} do
	response = conn \|> post("/api/pleroma/admin/oauth_app", %{}) \|> json_response(200)

	assert response == %{"name" => "can't be blank", "redirect_uris" => "can't be blank"}
	end

	test "success", %{conn: conn} do
	base_url = Web.base_url()
	app_name = "Trusted app"

	response =
	conn
	\|> post("/api/pleroma/admin/oauth_app", %{
	name: app_name,
	redirect_uris: base_url
	})
	\|> json_response(200)

	assert %{
	"client_id" => _,
	"client_secret" => _,
	"name" => ^app_name,
	"redirect_uri" => ^base_url,
	"trusted" => false
	} = response
	end

	test "with trusted", %{conn: conn} do
	base_url = Web.base_url()
	app_name = "Trusted app"

	response =
	conn
	\|> post("/api/pleroma/admin/oauth_app", %{
	name: app_name,
	redirect_uris: base_url,
	trusted: true
	})
	\|> json_response(200)

	assert %{
	"client_id" => _,
	"client_secret" => _,
	"name" => ^app_name,
	"redirect_uri" => ^base_url,
	"trusted" => true
	} = response
	end
	end

	describe "GET /api/pleroma/admin/oauth_app" do
	setup do
	app = insert(:oauth_app)
	{:ok, app: app}
	end

	test "list", %{conn: conn} do
	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app")
	\|> json_response(200)

	assert %{"apps" => apps, "count" => count, "page_size" => _} = response

	assert length(apps) == count
	end

	test "with page size", %{conn: conn} do
	insert(:oauth_app)
	page_size = 1

	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app", %{page_size: to_string(page_size)})
	\|> json_response(200)

	assert %{"apps" => apps, "count" => _, "page_size" => ^page_size} = response

	assert length(apps) == page_size
	end

	test "search by client name", %{conn: conn, app: app} do
	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app", %{name: app.client_name})
	\|> json_response(200)

	assert %{"apps" => [returned], "count" => _, "page_size" => _} = response

	assert returned["client_id"] == app.client_id
	assert returned["name"] == app.client_name
	end

	test "search by client id", %{conn: conn, app: app} do
	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app", %{client_id: app.client_id})
	\|> json_response(200)

	assert %{"apps" => [returned], "count" => _, "page_size" => _} = response

	assert returned["client_id"] == app.client_id
	assert returned["name"] == app.client_name
	end

	test "only trusted", %{conn: conn} do
	app = insert(:oauth_app, trusted: true)

	response =
	conn
	\|> get("/api/pleroma/admin/oauth_app", %{trusted: true})
	\|> json_response(200)

	assert %{"apps" => [returned], "count" => _, "page_size" => _} = response

	assert returned["client_id"] == app.client_id
	assert returned["name"] == app.client_name
	end
	end

	describe "DELETE /api/pleroma/admin/oauth_app/:id" do
	test "with id", %{conn: conn} do
	app = insert(:oauth_app)

	response =
	conn
	\|> delete("/api/pleroma/admin/oauth_app/" <> to_string(app.id))
	\|> json_response(:no_content)

	assert response == ""
	end

	test "with non existance id", %{conn: conn} do
	response =
	conn
	\|> delete("/api/pleroma/admin/oauth_app/0")
	\|> json_response(:bad_request)

	assert response == ""
	end
	end

	describe "PATCH /api/pleroma/admin/oauth_app/:id" do
	test "with id", %{conn: conn} do
	app = insert(:oauth_app)

	name = "another name"
	url = "https://example.com"
	scopes = ["admin"]
	id = app.id
	website = "http://website.com"

	response =
	conn
	\|> patch("/api/pleroma/admin/oauth_app/" <> to_string(app.id), %{
	name: name,
	trusted: true,
	redirect_uris: url,
	scopes: scopes,
	website: website
	})
	\|> json_response(200)

	assert %{
	"client_id" => _,
	"client_secret" => _,
	"id" => ^id,
	"name" => ^name,
	"redirect_uri" => ^url,
	"trusted" => true,
	"website" => ^website
	} = response
	end

	test "without id", %{conn: conn} do
	response =
	conn
	\|> patch("/api/pleroma/admin/oauth_app/0")
	\|> json_response(:bad_request)

	assert response == ""
	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/controllers/status_controller_test.exs b/test/web/admin_api/controllers/status_controller_test.exs
	new file mode 100644
	index 000000000..124d8dc2e
	--- /dev/null
	+++ b/test/web/admin_api/controllers/status_controller_test.exs
	@@ -0,0 +1,194 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.AdminAPI.StatusControllerTest do
	+ use Pleroma.Web.ConnCase
	+
	+ import Pleroma.Factory
	+
	+ alias Pleroma.Activity
	+ alias Pleroma.Config
	+ alias Pleroma.ModerationLog
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	+ alias Pleroma.Web.CommonAPI
	+
	+ setup do
	+ admin = insert(:user, is_admin: true)
	+ token = insert(:oauth_admin_token, user: admin)
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> assign(:token, token)
	+
	+ {:ok, %{admin: admin, token: token, conn: conn}}
	+ end
	+
	+ describe "GET /api/pleroma/admin/statuses/:id" do
	+ test "not found", %{conn: conn} do
	+ assert conn
	+ \|> get("/api/pleroma/admin/statuses/not_found")
	+ \|> json_response_and_validate_schema(:not_found)
	+ end
	+
	+ test "shows activity", %{conn: conn} do
	+ activity = insert(:note_activity)
	+
	+ response =
	+ conn
	+ \|> get("/api/pleroma/admin/statuses/#{activity.id}")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert response["id"] == activity.id
	+ end
	+ end
	+
	+ describe "PUT /api/pleroma/admin/statuses/:id" do
	+ setup do
	+ activity = insert(:note_activity)
	+
	+ %{id: activity.id}
	+ end
	+
	+ test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
	+ response =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
	+ \|> json_response_and_validate_schema(:ok)
	+
	+ assert response["sensitive"]
	+
	+ log_entry = Repo.one(ModerationLog)
	+
	+ assert ModerationLog.get_log_entry_message(log_entry) ==
	+ "@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"
	+
	+ response =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
	+ \|> json_response_and_validate_schema(:ok)
	+
	+ refute response["sensitive"]
	+ end
	+
	+ test "change visibility flag", %{conn: conn, id: id, admin: admin} do
	+ response =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "public"})
	+ \|> json_response_and_validate_schema(:ok)
	+
	+ assert response["visibility"] == "public"
	+
	+ log_entry = Repo.one(ModerationLog)
	+
	+ assert ModerationLog.get_log_entry_message(log_entry) ==
	+ "@#{admin.nickname} updated status ##{id}, set visibility: 'public'"
	+
	+ response =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "private"})
	+ \|> json_response_and_validate_schema(:ok)
	+
	+ assert response["visibility"] == "private"
	+
	+ response =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "unlisted"})
	+ \|> json_response_and_validate_schema(:ok)
	+
	+ assert response["visibility"] == "unlisted"
	+ end
	+
	+ test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
	+ conn =
	+ conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "test"})
	+
	+ assert %{"error" => "test - Invalid value for enum."} =
	+ json_response_and_validate_schema(conn, :bad_request)
	+ end
	+ end
	+
	+ describe "DELETE /api/pleroma/admin/statuses/:id" do
	+ setup do
	+ activity = insert(:note_activity)
	+
	+ %{id: activity.id}
	+ end
	+
	+ test "deletes status", %{conn: conn, id: id, admin: admin} do
	+ conn
	+ \|> delete("/api/pleroma/admin/statuses/#{id}")
	+ \|> json_response_and_validate_schema(:ok)
	+
	+ refute Activity.get_by_id(id)
	+
	+ log_entry = Repo.one(ModerationLog)
	+
	+ assert ModerationLog.get_log_entry_message(log_entry) ==
	+ "@#{admin.nickname} deleted status ##{id}"
	+ end
	+
	+ test "returns 404 when the status does not exist", %{conn: conn} do
	+ conn = delete(conn, "/api/pleroma/admin/statuses/test")
	+
	+ assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
	+ end
	+ end
	+
	+ describe "GET /api/pleroma/admin/statuses" do
	+ test "returns all public and unlisted statuses", %{conn: conn, admin: admin} do
	+ blocked = insert(:user)
	+ user = insert(:user)
	+ User.block(admin, blocked)
	+
	+ {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
	+
	+ {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
	+ {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
	+ {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
	+ {:ok, _} = CommonAPI.post(blocked, %{status: ".", visibility: "public"})
	+
	+ response =
	+ conn
	+ \|> get("/api/pleroma/admin/statuses")
	+ \|> json_response_and_validate_schema(200)
	+
	+ refute "private" in Enum.map(response, & &1["visibility"])
	+ assert length(response) == 3
	+ end
	+
	+ test "returns only local statuses with local_only on", %{conn: conn} do
	+ user = insert(:user)
	+ remote_user = insert(:user, local: false, nickname: "archaeme@archae.me")
	+ insert(:note_activity, user: user, local: true)
	+ insert(:note_activity, user: remote_user, local: false)
	+
	+ response =
	+ conn
	+ \|> get("/api/pleroma/admin/statuses?local_only=true")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert length(response) == 1
	+ end
	+
	+ test "returns private and direct statuses with godmode on", %{conn: conn, admin: admin} do
	+ user = insert(:user)
	+
	+ {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
	+
	+ {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
	+ {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
	+ conn = get(conn, "/api/pleroma/admin/statuses?godmode=true")
	+ assert json_response_and_validate_schema(conn, 200) \|> length() == 3
	+ end
	+ end
	+end
	diff --git a/test/web/feed/user_controller_test.exs b/test/web/feed/user_controller_test.exs
	index 05ad427c2..fa2ed1ea5 100644
	--- a/test/web/feed/user_controller_test.exs
	+++ b/test/web/feed/user_controller_test.exs
	@@ -1,214 +1,238 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Feed.UserControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import SweetXml

	alias Pleroma.Config
	alias Pleroma.Object
	alias Pleroma.User
	+ alias Pleroma.Web.CommonAPI

	setup do: clear_config([:instance, :federating], true)

	describe "feed" do
	setup do: clear_config([:feed])

	- test "gets a feed", %{conn: conn} do
	+ test "gets an atom feed", %{conn: conn} do
	Config.put(
	[:feed, :post_title],
	%{max_length: 10, omission: "..."}
	)

	activity = insert(:note_activity)

	note =
	insert(:note,
	data: %{
	"content" => "This is :moominmamma: note ",
	"attachment" => [
	%{
	"url" => [
	%{"mediaType" => "image/png", "href" => "https://pleroma.gov/image.png"}
	]
	}
	],
	"inReplyTo" => activity.data["id"]
	}
	)

	note_activity = insert(:note_activity, note: note)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	note2 =
	insert(:note,
	user: user,
	data: %{
	"content" => "42 This is :moominmamma: note ",
	"inReplyTo" => activity.data["id"]
	}
	)

	note_activity2 = insert(:note_activity, note: note2)
	object = Object.normalize(note_activity)

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == ['42 This...', 'This is...']
	assert resp =~ object.data["content"]

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get("/users/#{user.nickname}/feed", %{"max_id" => note_activity2.id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == ['This is...']
	end

	test "gets a rss feed", %{conn: conn} do
	Pleroma.Config.put(
	[:feed, :post_title],
	%{max_length: 10, omission: "..."}
	)

	activity = insert(:note_activity)

	note =
	insert(:note,
	data: %{
	"content" => "This is :moominmamma: note ",
	"attachment" => [
	%{
	"url" => [
	%{"mediaType" => "image/png", "href" => "https://pleroma.gov/image.png"}
	]
	}
	],
	"inReplyTo" => activity.data["id"]
	}
	)

	note_activity = insert(:note_activity, note: note)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	note2 =
	insert(:note,
	user: user,
	data: %{
	"content" => "42 This is :moominmamma: note ",
	"inReplyTo" => activity.data["id"]
	}
	)

	note_activity2 = insert(:note_activity, note: note2)
	object = Object.normalize(note_activity)

	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	assert activity_titles == ['42 This...', 'This is...']
	assert resp =~ object.data["content"]

	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss", %{"max_id" => note_activity2.id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	assert activity_titles == ['This is...']
	end

	test "returns 404 for a missing feed", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, "nonexisting"))

	assert response(conn, 404)
	end
	+
	+ test "returns feed with public and unlisted activities", %{conn: conn} do
	+ user = insert(:user)
	+
	+ {:ok, _} = CommonAPI.post(user, %{status: "public", visibility: "public"})
	+ {:ok, _} = CommonAPI.post(user, %{status: "direct", visibility: "direct"})
	+ {:ok, _} = CommonAPI.post(user, %{status: "unlisted", visibility: "unlisted"})
	+ {:ok, _} = CommonAPI.post(user, %{status: "private", visibility: "private"})
	+
	+ resp =
	+ conn
	+ \|> put_req_header("accept", "application/atom+xml")
	+ \|> get(user_feed_path(conn, :feed, user.nickname))
	+ \|> response(200)
	+
	+ activity_titles =
	+ resp
	+ \|> SweetXml.parse()
	+ \|> SweetXml.xpath(~x"//entry/title/text()"l)
	+ \|> Enum.sort()
	+
	+ assert activity_titles == ['public', 'unlisted']
	+ end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "feed_redirect" do
	test "with html format, it redirects to user feed", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	response =
	conn
	\|> get("/users/#{user.nickname}")
	\|> response(200)

	assert response ==
	Fallback.RedirectController.redirector_with_meta(
	conn,
	%{user: user}
	).resp_body
	end

	test "with html format, it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == %{"error" => "Not found"}
	end

	test "with non-html / non-json format, it redirects to user feed in atom format", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/users/#{user.nickname}")

	assert conn.status == 302
	assert redirected_to(conn) == "#{Pleroma.Web.base_url()}/users/#{user.nickname}/feed.atom"
	end

	test "with non-html / non-json format, it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get(user_feed_path(conn, :feed, "jimm"))
	\|> response(404)

	assert response == ~S({"error":"Not found"})
	end
	end
	end
	diff --git a/test/web/ostatus/ostatus_controller_test.exs b/test/web/ostatus/ostatus_controller_test.exs
	index bb349cb19..ee498f4b5 100644
	--- a/test/web/ostatus/ostatus_controller_test.exs
	+++ b/test/web/ostatus/ostatus_controller_test.exs
	@@ -1,293 +1,338 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.OStatusControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory

	alias Pleroma.Config
	alias Pleroma.Object
	alias Pleroma.User
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	+ alias Pleroma.Web.Endpoint
	+
	+ require Pleroma.Constants

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :federating], true)

	+ describe "Mastodon compatibility routes" do
	+ setup %{conn: conn} do
	+ conn = put_req_header(conn, "accept", "text/html")
	+
	+ {:ok, object} =
	+ %{
	+ "type" => "Note",
	+ "content" => "hey",
	+ "id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	+ "actor" => Endpoint.url() <> "/users/raymoo",
	+ "to" => [Pleroma.Constants.as_public()]
	+ }
	+ \|> Object.create()
	+
	+ {:ok, activity, _} =
	+ %{
	+ "id" => object.data["id"] <> "/activity",
	+ "type" => "Create",
	+ "object" => object.data["id"],
	+ "actor" => object.data["actor"],
	+ "to" => object.data["to"]
	+ }
	+ \|> ActivityPub.persist(local: true)
	+
	+ %{conn: conn, activity: activity}
	+ end
	+
	+ test "redirects to /notice/:id for html format", %{conn: conn, activity: activity} do
	+ conn = get(conn, "/users/raymoo/statuses/999999999")
	+ assert redirected_to(conn) == "/notice/#{activity.id}"
	+ end
	+
	+ test "redirects to /notice/:id for html format for activity", %{
	+ conn: conn,
	+ activity: activity
	+ } do
	+ conn = get(conn, "/users/raymoo/statuses/999999999/activity")
	+ assert redirected_to(conn) == "/notice/#{activity.id}"
	+ end
	+ end
	+
	# Note: see ActivityPubControllerTest for JSON format tests
	describe "GET /objects/:uuid (text/html)" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	%{conn: conn}
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))
	url = "/objects/#{uuid}"

	conn = get(conn, url)
	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "404s on private objects", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	object = Object.normalize(note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, object.data["id"]))

	conn
	\|> get("/objects/#{uuid}")
	\|> response(404)
	end

	test "404s on non-existing objects", %{conn: conn} do
	conn
	\|> get("/objects/123")
	\|> response(404)
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "GET /activities/:uuid (text/html)" do
	setup %{conn: conn} do
	conn = put_req_header(conn, "accept", "text/html")
	%{conn: conn}
	end

	test "redirects to /notice/id for html format", %{conn: conn} do
	note_activity = insert(:note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn = get(conn, "/activities/#{uuid}")
	assert redirected_to(conn) == "/notice/#{note_activity.id}"
	end

	test "404s on private activities", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	[_, uuid] = hd(Regex.scan(~r/.+\/([\w-]+)$/, note_activity.data["id"]))

	conn
	\|> get("/activities/#{uuid}")
	\|> response(404)
	end

	test "404s on nonexistent activities", %{conn: conn} do
	conn
	\|> get("/activities/123")
	\|> response(404)
	end
	end

	describe "GET notice/2" do
	test "redirects to a proper object URL when json requested and the object is local", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	expected_redirect_url = Object.normalize(note_activity).data["id"]

	redirect_url =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> redirected_to()

	assert redirect_url == expected_redirect_url
	end

	test "returns a 404 on remote notice when json requested", %{conn: conn} do
	note_activity = insert(:note_activity, local: false)

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/notice/#{note_activity.id}")
	\|> response(404)
	end

	test "500s when actor not found", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])
	User.invalidate_cache(user)
	Pleroma.Repo.delete(user)

	conn =
	conn
	\|> get("/notice/#{note_activity.id}")

	assert response(conn, 500) == ~S({"error":"Something went wrong"})
	end

	test "render html for redirect for html format", %{conn: conn} do
	note_activity = insert(:note_activity)

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{note_activity.id}")
	\|> response(200)

	assert resp =~
	"<meta content=\"#{Pleroma.Web.base_url()}/notice/#{note_activity.id}\" property=\"og:url\">"

	user = insert(:user)

	{:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)

	assert like_activity.data["type"] == "Like"

	resp =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/notice/#{like_activity.id}")
	\|> response(200)

	assert resp =~ "<!--server-generated-meta-->"
	end

	test "404s a private notice", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	url = "/notice/#{note_activity.id}"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "404s a non-existing notice", %{conn: conn} do
	url = "/notice/123"

	conn =
	conn
	\|> get(url)

	assert response(conn, 404)
	end

	test "it requires authentication if instance is NOT federating", %{
	conn: conn
	} do
	user = insert(:user)
	note_activity = insert(:note_activity)

	conn = put_req_header(conn, "accept", "text/html")

	ensure_federating_or_authenticated(conn, "/notice/#{note_activity.id}", user)
	end
	end

	describe "GET /notice/:id/embed_player" do
	setup do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	%{note_activity: note_activity}
	end

	test "renders embed player", %{conn: conn, note_activity: note_activity} do
	conn = get(conn, "/notice/#{note_activity.id}/embed_player")

	assert Plug.Conn.get_resp_header(conn, "x-frame-options") == ["ALLOW"]

	assert Plug.Conn.get_resp_header(
	conn,
	"content-security-policy"
	) == [
	"default-src 'none';style-src 'self' 'unsafe-inline';img-src 'self' data: https:; media-src 'self' https:;"
	]

	assert response(conn, 200) =~
	"<video controls loop><source src=\"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4\" type=\"video/mp4\">Your browser does not support video/mp4 playback.</video>"
	end

	test "404s when activity isn't create", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"type" => "Like"})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when activity is direct message", %{conn: conn} do
	note_activity = insert(:note_activity, data_attrs: %{"directMessage" => true})

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment is empty", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)
	object_data = Map.put(object.data, "attachment", [])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	assert conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "404s when attachment isn't audio or video", %{conn: conn} do
	note_activity = insert(:note_activity)
	object = Pleroma.Object.normalize(note_activity)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" => "https://peertube.moe/static/webseed/480.jpg",
	"mediaType" => "image/jpg",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	conn
	\|> get("/notice/#{note_activity.id}/embed_player")
	\|> response(404)
	end

	test "it requires authentication if instance is NOT federating", %{
	conn: conn,
	note_activity: note_activity
	} do
	user = insert(:user)
	conn = put_req_header(conn, "accept", "text/html")

	ensure_federating_or_authenticated(conn, "/notice/#{note_activity.id}/embed_player", user)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Tue, Oct 13, 9:16 PM (1 d, 21 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1786906
Default Alt Text: (433 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions