No OneTemporary
Actions

Authored By

Unknown

Size

797 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
	index dc953a929..121e4abfe 100644
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -1,350 +1,350 @@
	image: elixir:1.9.4

	variables: &global_variables
	POSTGRES_DB: pleroma_test
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	DB_HOST: postgres
	MIX_ENV: test

	cache: &global_cache_policy
	key: ${CI_COMMIT_REF_SLUG}
	paths:
	- deps
	- _build

	stages:
	- build
	- test
	- benchmark
	- deploy
	- release
	- docker

	before_script:
	- apt-get update && apt-get install -y cmake
	- mix local.hex --force
	- mix local.rebar --force

	build:
	stage: build
	script:
	- mix deps.get
	- mix compile --force

	benchmark:
	stage: benchmark
	when: manual
	variables:
	MIX_ENV: benchmark
	services:
	- name: postgres:9.6
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix deps.get
	- mix ecto.create
	- mix ecto.migrate
	- mix pleroma.load_testing

	unit-testing:
	stage: test
	retry: 2
	cache: &testing_cache_policy
	<<: *global_cache_policy
	policy: pull

	services:
	- name: postgres:9.6
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- - apt-get update && apt-get install -y libimage-exiftool-perl
	+ - apt-get update && apt-get install -y libimage-exiftool-perl ffmpeg
	- mix deps.get
	- mix ecto.create
	- mix ecto.migrate
	- mix coveralls --preload-modules

	# Removed to fix CI issue. In this early state it wasn't adding much value anyway.
	# TODO Fix and reinstate federated testing
	# federated-testing:
	# stage: test
	# cache: *testing_cache_policy
	# services:
	# - name: minibikini/postgres-with-rum:12
	# alias: postgres
	# command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	# script:
	# - mix deps.get
	# - mix ecto.create
	# - mix ecto.migrate
	# - epmd -daemon
	# - mix test --trace --only federated

	unit-testing-rum:
	stage: test
	retry: 2
	cache: *testing_cache_policy
	services:
	- name: minibikini/postgres-with-rum:12
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	variables:
	<<: *global_variables
	RUM_ENABLED: "true"
	script:
	- - apt-get update && apt-get install -y libimage-exiftool-perl
	+ - apt-get update && apt-get install -y libimage-exiftool-perl ffmpeg
	- mix deps.get
	- mix ecto.create
	- mix ecto.migrate
	- "mix ecto.migrate --migrations-path priv/repo/optional_migrations/rum_indexing/"
	- mix test --preload-modules

	lint:
	stage: test
	cache: *testing_cache_policy
	script:
	- mix format --check-formatted

	analysis:
	stage: test
	cache: *testing_cache_policy
	script:
	- mix deps.get
	- mix credo --strict --only=warnings,todo,fixme,consistency,readability

	docs-deploy:
	stage: deploy
	cache: *testing_cache_policy
	image: alpine:latest
	only:
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	before_script:
	- apk add curl
	script:
	- curl -X POST -F"token=$DOCS_PIPELINE_TRIGGER" -F'ref=master' -F"variables[BRANCH]=$CI_COMMIT_REF_NAME" https://git.pleroma.social/api/v4/projects/673/trigger/pipeline
	review_app:
	image: alpine:3.9
	stage: deploy
	before_script:
	- apk update && apk add openssh-client git
	when: manual
	environment:
	name: review/$CI_COMMIT_REF_NAME
	url: https://$CI_ENVIRONMENT_SLUG.pleroma.online/
	on_stop: stop_review_app
	only:
	- branches
	except:
	- master
	- develop
	script:
	- echo "$CI_ENVIRONMENT_SLUG"
	- mkdir -p ~/.ssh
	- eval $(ssh-agent -s)
	- echo "$SSH_PRIVATE_KEY" \| tr -d '\r' \| ssh-add -
	- ssh-keyscan -H "pleroma.online" >> ~/.ssh/known_hosts
	- (ssh -t dokku@pleroma.online -- apps:create "$CI_ENVIRONMENT_SLUG") \|\| true
	- (ssh -t dokku@pleroma.online -- git:set "$CI_ENVIRONMENT_SLUG" keep-git-dir true) \|\| true
	- ssh -t dokku@pleroma.online -- config:set "$CI_ENVIRONMENT_SLUG" APP_NAME="$CI_ENVIRONMENT_SLUG" APP_HOST="$CI_ENVIRONMENT_SLUG.pleroma.online" MIX_ENV=dokku
	- (ssh -t dokku@pleroma.online -- postgres:create $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db) \|\| true
	- (ssh -t dokku@pleroma.online -- postgres:link $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db "$CI_ENVIRONMENT_SLUG") \|\| true
	- (ssh -t dokku@pleroma.online -- certs:add "$CI_ENVIRONMENT_SLUG" /home/dokku/server.crt /home/dokku/server.key) \|\| true
	- git push -f dokku@pleroma.online:$CI_ENVIRONMENT_SLUG $CI_COMMIT_SHA:refs/heads/master

	stop_review_app:
	image: alpine:3.9
	stage: deploy
	before_script:
	- apk update && apk add openssh-client git
	when: manual
	environment:
	name: review/$CI_COMMIT_REF_NAME
	action: stop
	script:
	- echo "$CI_ENVIRONMENT_SLUG"
	- mkdir -p ~/.ssh
	- eval $(ssh-agent -s)
	- echo "$SSH_PRIVATE_KEY" \| tr -d '\r' \| ssh-add -
	- ssh-keyscan -H "pleroma.online" >> ~/.ssh/known_hosts
	- ssh -t dokku@pleroma.online -- --force apps:destroy "$CI_ENVIRONMENT_SLUG"
	- ssh -t dokku@pleroma.online -- --force postgres:destroy $(echo $CI_ENVIRONMENT_SLUG \| sed -e 's/-/_/g')_db

	amd64:
	stage: release
	image: elixir:1.10.3
	only: &release-only
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	- /^maint/.*$/@pleroma/pleroma
	- /^release/.*$/@pleroma/pleroma
	artifacts: &release-artifacts
	name: "pleroma-$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA-$CI_JOB_NAME"
	paths:
	- release/*
	# Ideally it would be never for master branch and with the next commit for develop,
	# but Gitlab does not support neither `only` for artifacts
	# nor setting it to never from .gitlab-ci.yml
	# nor expiring with the next commit
	expire_in: 42 yrs

	cache: &release-cache
	key: $CI_COMMIT_REF_NAME-$CI_JOB_NAME
	paths:
	- deps
	variables: &release-variables
	MIX_ENV: prod
	before_script: &before-release
	- apt-get update && apt-get install -y cmake
	- echo "import Mix.Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: &release
	- mix deps.get --only prod
	- mkdir release
	- export PLEROMA_BUILD_BRANCH=$CI_COMMIT_REF_NAME
	- mix release --path release


	amd64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	image: elixir:1.10.3-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: &before-release-musl
	- apk add git gcc g++ musl-dev make cmake
	- echo "import Mix.Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: *release

	arm:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32
	image: elixir:1.10.3
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32
	image: elixir:1.10.3-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	arm64:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	image: elixir:1.10.3
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	# TODO: Replace with upstream image when 1.9.0 comes out
	image: elixir:1.10.3-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	docker:
	stage: docker
	image: docker:latest
	cache: {}
	dependencies: []
	variables: &docker-variables
	DOCKER_DRIVER: overlay2
	DOCKER_HOST: unix:///var/run/docker.sock
	IMAGE_TAG: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
	IMAGE_TAG_SLUG: $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
	IMAGE_TAG_LATEST: $CI_REGISTRY_IMAGE:latest
	IMAGE_TAG_LATEST_STABLE: $CI_REGISTRY_IMAGE:latest-stable
	DOCKER_BUILDX_URL: https://github.com/docker/buildx/releases/download/v0.4.1/buildx-v0.4.1.linux-amd64
	DOCKER_BUILDX_HASH: 71a7d01439aa8c165a25b59c44d3f016fddbd98b
	before_script: &before-docker
	- docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
	- docker pull $IMAGE_TAG_SLUG \|\| true
	- export CI_JOB_TIMESTAMP=$(date --utc -Iseconds)
	- export CI_VCS_REF=$CI_COMMIT_SHORT_SHA
	allow_failure: true
	script:
	- mkdir -p /root/.docker/cli-plugins
	- wget "${DOCKER_BUILDX_URL}" -O ~/.docker/cli-plugins/docker-buildx
	- echo "${DOCKER_BUILDX_HASH} /root/.docker/cli-plugins/docker-buildx" \| sha1sum -c
	- chmod +x ~/.docker/cli-plugins/docker-buildx
	- docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
	- docker buildx create --name mbuilder --driver docker-container --use
	- docker buildx inspect --bootstrap
	- docker buildx build --platform linux/amd64,linux/arm/v7,linux/arm64/v8 --push --cache-from $IMAGE_TAG_SLUG --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP -t $IMAGE_TAG -t $IMAGE_TAG_SLUG -t $IMAGE_TAG_LATEST .
	tags:
	- dind
	only:
	- develop@pleroma/pleroma

	docker-stable:
	stage: docker
	image: docker:latest
	cache: {}
	dependencies: []
	variables: *docker-variables
	before_script: *before-docker
	allow_failure: true
	script:
	- mkdir -p /root/.docker/cli-plugins
	- wget "${DOCKER_BUILDX_URL}" -O ~/.docker/cli-plugins/docker-buildx
	- echo "${DOCKER_BUILDX_HASH} /root/.docker/cli-plugins/docker-buildx" \| sha1sum -c
	- chmod +x ~/.docker/cli-plugins/docker-buildx
	- docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
	- docker buildx create --name mbuilder --driver docker-container --use
	- docker buildx inspect --bootstrap
	- docker buildx build --platform linux/amd64,linux/arm/v7,linux/arm64/v8 --push --cache-from $IMAGE_TAG_SLUG --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP -t $IMAGE_TAG -t $IMAGE_TAG_SLUG -t $IMAGE_TAG_LATEST_STABLE .
	tags:
	- dind
	only:
	- stable@pleroma/pleroma

	docker-release:
	stage: docker
	image: docker:latest
	cache: {}
	dependencies: []
	variables: *docker-variables
	before_script: *before-docker
	allow_failure: true
	script:
	script:
	- mkdir -p /root/.docker/cli-plugins
	- wget "${DOCKER_BUILDX_URL}" -O ~/.docker/cli-plugins/docker-buildx
	- echo "${DOCKER_BUILDX_HASH} /root/.docker/cli-plugins/docker-buildx" \| sha1sum -c
	- chmod +x ~/.docker/cli-plugins/docker-buildx
	- docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
	- docker buildx create --name mbuilder --driver docker-container --use
	- docker buildx inspect --bootstrap
	- docker buildx build --platform linux/amd64,linux/arm/v7,linux/arm64/v8 --push --cache-from $IMAGE_TAG_SLUG --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP -t $IMAGE_TAG -t $IMAGE_TAG_SLUG .
	tags:
	- dind
	only:
	- /^release/.*$/@pleroma/pleroma
	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index 80fbc078d..9ae5d0eda 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,946 +1,962 @@
	# 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

	### Added
	- Mix tasks for controlling user account confirmation status in bulk (`mix pleroma.user confirm_all` and `mix pleroma.user unconfirm_all`)
	- Mix task for sending confirmation emails to all unconfirmed users (`mix pleroma.email send_confirmation_mails`)
	+- Mix task option for force-unfollowing relays

	### Changed

	+- Breaking: Pleroma Admin API: emoji packs and files routes changed.
	- Search: Users are now findable by their urls.
	- Renamed `:await_up_timeout` in `:connections_pool` namespace to `:connect_timeout`, old name is deprecated.
	- Renamed `:timeout` in `pools` namespace to `:recv_timeout`, old name is deprecated.
	- The `discoverable` field in the `User` struct will now add a NOINDEX metatag to profile pages when false.
	- Users with the `discoverable` field set to false will not show up in searches.
	- Minimum lifetime for ephmeral activities changed to 10 minutes and made configurable (`:min_lifetime` option).
	+- Introduced optional dependencies on `ffmpeg`, `ImageMagick`, `exiftool` software packages. Please refer to `docs/installation/optional/media_graphics_packages.md`.

	### Added
	-- Media preview proxy (requires media proxy be enabled; see `:media_preview_proxy` config for more details).
	+- Media preview proxy (requires `ffmpeg` and `ImageMagick` to be installed and media proxy to be enabled; see `:media_preview_proxy` config for more details).
	- Pleroma API: Importing the mutes users from CSV files.
	- Experimental websocket-based federation between Pleroma instances.
	+
	+<details>
	+ <summary>API Changes</summary>
	+
	+- Pleroma API: Importing the mutes users from CSV files.
	- Admin API: Importing emoji from a zip file
	+- Pleroma API: Pagination for remote/local packs and emoji.
	+
	+</details>

	### Removed

	- Breaking: `Pleroma.Workers.Cron.StatsWorker` setting from Oban `:crontab` (moved to a simpler implementation).
	- Breaking: `Pleroma.Workers.Cron.ClearOauthTokenWorker` setting from Oban `:crontab` (moved to scheduled jobs).
	- Breaking: `Pleroma.Workers.Cron.PurgeExpiredActivitiesWorker` setting from Oban `:crontab` (moved to scheduled jobs).
	- Removed `:managed_config` option. In practice, it was accidentally removed with 2.0.0 release when frontends were
	switched to a new configuration mechanism, however it was not officially removed until now.

	### Fixed

	- Add documented-but-missing chat pagination.
	- Allow sending out emails again.

	+## Unreleased (Patch)
	+
	+### Changed
	+- API: Empty parameter values for integer parameters are now ignored in non-strict validaton mode.
	+
	## [2.1.2] - 2020-09-17

	### Security

	- Fix most MRF rules either crashing or not being applied to objects passed into the Common Pipeline (ChatMessage, Question, Answer, Audio, Event).

	### Fixed

	- Welcome Chat messages preventing user registration with MRF Simple Policy applied to the local instance.
	- Mastodon API: the public timeline returning an error when the `reply_visibility` parameter is set to `self` for an unauthenticated user.
	- Mastodon Streaming API: Handler crashes on authentication failures, resulting in error logs.
	- Mastodon Streaming API: Error logs on client pings.
	- Rich media: Log spam on failures. Now the error is only logged once per attempt.

	### Changed

	- Rich Media: A HEAD request is now done to the url, to ensure it has the appropriate content type and size before proceeding with a GET.

	### Upgrade notes

	1. Restart Pleroma

	## [2.1.1] - 2020-09-08

	### Security
	- Fix possible DoS in Mastodon API user search due to an error in match clauses, leading to an infinite recursion and subsequent OOM with certain inputs.
	- Fix metadata leak for accounts and statuses on private instances.
	- Fix possible DoS in Admin API search using an atom leak vulnerability. Authentication with admin rights was required to exploit.

	### Changed

	- Breaking: The metadata providers RelMe and Feed are no longer configurable. RelMe should always be activated and Feed only provides a <link> header tag for the actual RSS/Atom feed when the instance is public.
	- Improved error message when cmake is not available at build stage.

	### Added
	- Rich media failure tracking (along with `:failure_backoff` option).

	<details>
	<summary>Admin API Changes</summary>

	- Add `PATCH /api/pleroma/admin/instance_document/:document_name` to modify the Terms of Service and Instance Panel HTML pages via Admin API
	</details>

	### Fixed
	- Default HTTP adapter not respecting pool setting, leading to possible OOM.
	- Fixed uploading webp images when the Exiftool Upload Filter is enabled by skipping them
	- Mastodon API: Search parameter `following` now correctly returns the followings rather than the followers
	- Mastodon API: Timelines hanging for (`number of posts with links * rich media timeout`) in the worst case.
	Reduced to just rich media timeout.
	- Mastodon API: Cards being wrong for preview statuses due to cache key collision.
	- Password resets no longer processed for deactivated accounts.
	- Favicon scraper raising exceptions on URLs longer than 255 characters.

	## [2.1.0] - 2020-08-28

	### Changed

	- Breaking: The default descriptions on uploads are now empty. The old behavior (filename as default) can be configured, see the cheat sheet.
	- Breaking: Added the ObjectAgePolicy to the default set of MRFs. This will delist and strip the follower collection of any message received that is older than 7 days. This will stop users from seeing very old messages in the timelines. The messages can still be viewed on the user's page and in conversations. They also still trigger notifications.
	- Breaking: Elixir >=1.9 is now required (was >= 1.8)
	- Breaking: Configuration: `:auto_linker, :opts` moved to `:pleroma, Pleroma.Formatter`. Old config namespace is deprecated.
	- Breaking: Configuration: `:instance, welcome_user_nickname` moved to `:welcome, :direct_message, :sender_nickname`, `:instance, :welcome_message` moved to `:welcome, :direct_message, :message`. Old config namespace is deprecated.
	- Breaking: LDAP: Fallback to local database authentication has been removed for security reasons and lack of a mechanism to ensure the passwords are synchronized when LDAP passwords are updated.
	- Breaking Changed defaults for `:restrict_unauthenticated` so that when `:instance, :public` is set to `false` then all `:restrict_unauthenticated` items be effectively set to `true`. If you'd like to allow unauthenticated access to specific API endpoints on a private instance, please explicitly set `:restrict_unauthenticated` to non-default value in `config/prod.secret.exs`.
	- In Conversations, return only direct messages as `last_status`
	- Using the `only_media` filter on timelines will now exclude reblog media
	- MFR policy to set global expiration for all local Create activities
	- OGP rich media parser merged with TwitterCard
	- Configuration: `:instance, rewrite_policy` moved to `:mrf, policies`, `:instance, :mrf_transparency` moved to `:mrf, :transparency`, `:instance, :mrf_transparency_exclusions` moved to `:mrf, :transparency_exclusions`. Old config namespace is deprecated.
	- Configuration: `:media_proxy, whitelist` format changed to host with scheme (e.g. `http://example.com` instead of `example.com`). Domain format is deprecated.

	<details>
	<summary>API Changes</summary>

	- Breaking: Pleroma API: The routes to update avatar, banner and background have been removed.
	- Breaking: Image description length is limited now.
	- Breaking: Emoji API: changed methods and renamed routes.
	- Breaking: Notification Settings API for suppressing notifications has been simplified down to `block_from_strangers`.
	- Breaking: Notification Settings API option for hiding push notification contents has been renamed to `hide_notification_contents`.
	- MastodonAPI: Allow removal of avatar, banner and background.
	- Streaming: Repeats of a user's posts will no longer be pushed to the user's stream.
	- Mastodon API: Added `pleroma.metadata.fields_limits` to /api/v1/instance
	- Mastodon API: On deletion, returns the original post text.
	- Mastodon API: Add `pleroma.unread_count` to the Marker entity.
	- Mastodon API: Added `pleroma.metadata.post_formats` to /api/v1/instance
	- Mastodon API (legacy): Allow query parameters for `/api/v1/domain_blocks`, e.g. `/api/v1/domain_blocks?domain=badposters.zone`
	- Mastodon API: Make notifications about statuses from muted users and threads read automatically
	- Pleroma API: `/api/pleroma/captcha` responses now include `seconds_valid` with an integer value.

	</details>

	<details>
	<summary>Admin API Changes</summary>

	- Breaking Changed relay `/api/pleroma/admin/relay` endpoints response format.
	- Status visibility stats: now can return stats per instance.
	- Mix task to refresh counter cache (`mix pleroma.refresh_counter_cache`)

	</details>

	### Removed

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

	### Added

	- Frontends: Add mix task to install frontends.
	- Frontends: Add configurable frontends for primary and admin fe.
	- Configuration: Added a blacklist for email servers.
	- Chats: Added `accepts_chat_messages` field to user, exposed in APIs and federation.
	- Chats: Added support for federated chats. For details, see the docs.
	- 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.
	- Mix task to reset MFA for user accounts
	- 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
	- Support pagination in emoji packs API (for packs and for files in pack)
	- Support for viewing instances favicons next to posts and accounts
	- Added Pleroma.Upload.Filter.Exiftool as an alternate EXIF stripping mechanism targeting GPS/location metadata.
	- "By approval" registrations mode.
	- Configuration: Added `:welcome` settings for the welcome message to newly registered users. You can send a welcome message as a direct message, chat or email.
	- Ability to hide favourites and emoji reactions in the API with `[:instance, :show_reactions]` config.

	<details>
	<summary>API Changes</summary>

	- Mastodon API: Add pleroma.parent_visible field to statuses.
	- 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.
	- Mastodon API: Support for `bot` field in `/api/v1/accounts/update_credentials`.
	- Mastodon API: Support irreversible property for filters.
	- Mastodon API: Add pleroma.favicon field to accounts.
	- Admin API: endpoints for create/update/delete OAuth Apps.
	- Admin API: endpoint for status view.
	- OTP: Add command to reload emoji packs
	</details>

	### Fixed
	- Fix list pagination and other list issues.
	- 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
	- `blob:` urls not being allowed by connect-src CSP
	- Mastodon API: fix `GET /api/v1/notifications` not returning the full result set
	- Rich Media Previews for Twitter links
	- Admin API: fix `GET /api/pleroma/admin/users/:nickname/credentials` returning 404 when getting the credentials of a remote user while `:instance, :limit_to_local_content` is set to `:unauthenticated`
	- Fix CSP policy generation to include remote Captcha services
	- Fix edge case where MediaProxy truncates media, usually caused when Caddy is serving content for the other Federated instance.
	- Emoji Packs could not be listed when instance was set to `public: false`
	- Fix whole_word always returning false on filter get requests
	- Migrations not working on OTP releases if the database was connected over ssl
	- Fix relay following

	## [2.0.7] - 2020-06-13

	### Security
	- Fix potential DoSes exploiting atom leaks in rich media parser and the `UserAllowListPolicy` MRF policy

	### Fixed
	- CSP: not allowing images/media from every host when mediaproxy is disabled
	- CSP: not adding mediaproxy base url to image/media hosts
	- StaticFE missing the CSS file

	### Upgrade notes

	1. Restart Pleroma

	## [2.0.6] - 2020-06-09

	### Security
	- CSP: harden `image-src` and `media-src` when MediaProxy is used

	### Fixed
	- AP C2S: Fix pagination in inbox/outbox
	- Various compilation errors on OTP 23
	- Mastodon API streaming: Repeats from muted threads not being filtered

	### Changed
	- Various database performance improvements

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

	## [2.0.5] - 2020-05-13

	### Security
	- Fix possible private status leaks in Mastodon Streaming API

	### Fixed
	- Crashes when trying to block a user if block federation is disabled
	- Not being able to start the instance without `erlang-eldap` installed
	- Users with bios over the limit getting rejected
	- Follower counters not being updated on incoming follow accepts

	### Upgrade notes

	1. Restart Pleroma

	## [2.0.4] - 2020-05-10

	### Security
	- AP C2S: Fix a potential DoS by creating nonsensical objects that break timelines

	### Fixed
	- Peertube user lookups not working
	- `InsertSkeletonsForDeletedUsers` migration failing on some instances
	- Healthcheck reporting the number of memory currently used, rather than allocated in total
	- LDAP not being usable in OTP releases
	- Default apache configuration having tls chain issues

	### Upgrade notes

	#### Apache only

	1. Remove the following line from your config:
	```
	SSLCertificateFile /etc/letsencrypt/live/${servername}/cert.pem
	```

	#### Everyone

	1. Restart Pleroma

	## [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`
	3. Reset status visibility counters (inside Pleroma directory):
	- OTP: `./bin/pleroma_ctl refresh_counter_cache`
	- From Source: `mix pleroma.refresh_counter_cache`


	## [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
	=======
	- Rate limiter crashes when there is no explicitly specified ip in the config
	- 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.
	- 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/config/benchmark.exs b/config/benchmark.exs
	index e867253eb..5567ff26e 100644
	--- a/config/benchmark.exs
	+++ b/config/benchmark.exs
	@@ -1,90 +1,88 @@
	use Mix.Config

	# We don't run a server during test. If one is required,
	# you can enable the server option below.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4001],
	url: [port: 4001],
	server: true

	# Disable captha for tests
	config :pleroma, Pleroma.Captcha,
	# It should not be enabled for automatic tests
	enabled: false,
	# A fake captcha service for tests
	method: Pleroma.Captcha.Mock

	# Print only warnings and errors during test
	config :logger, level: :warn

	config :pleroma, :auth, oauth_consumer_strategies: []

	config :pleroma, Pleroma.Upload, filters: [], link_name: false

	config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test, enabled: true

	config :pleroma, :instance,
	email: "admin@example.com",
	notify_email: "noreply@example.com",
	skip_thread_containment: false,
	federating: false,
	external_user_synchronization: false

	config :pleroma, :activitypub, sign_object_fetches: false

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_benchmark",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	pool_size: 10

	# Reduce hash rounds for testing
	config :pbkdf2_elixir, rounds: 1

	config :tesla, adapter: Tesla.Mock

	config :pleroma, :rich_media,
	enabled: false,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"]

	config :web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BLH1qVhJItRGCfxgTtONfsOKDc9VRAraXw-3NsmjMngWSh7NxOizN6bkuRA7iLTMPS82PjwJAr3UoK9EC1IFrz4",
	private_key: "_-XZ0iebPrRfZ_o0-IatTdszYa8VCH1yLN-JauK7HHA"

	-config :web_push_encryption, :http_client, Pleroma.Web.WebPushHttpClientMock
	-
	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 2,
	total_user_limit: 3,
	enabled: false

	config :pleroma, :rate_limit,
	search: [{1000, 30}, {1000, 30}],
	app_account_creation: {10_000, 5},
	password_reset: {1000, 30}

	config :pleroma, :http_security, report_uri: "https://endpoint.com"

	config :pleroma, :http, send_user_agent: false

	rum_enabled = System.get_env("RUM_ENABLED") == "true"
	config :pleroma, :database, rum_enabled: rum_enabled
	IO.puts("RUM enabled: #{rum_enabled}")

	config :pleroma, Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.ClientMock

	if File.exists?("./config/benchmark.secret.exs") do
	import_config "benchmark.secret.exs"
	else
	IO.puts(
	"You may want to create benchmark.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/config/config.exs b/config/config.exs
	index 00624bf00..2e6b0796a 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,822 +1,822 @@
	# .i;;;;i.
	# iYcviii;vXY:
	# .YXi .i1c.
	# .YC. . in7.
	# .vc. ...... ;1c.
	# i7, .. .;1;
	# i7, .. ... .Y1i
	# ,7v .6MMM@; .YX,
	# .7;. ..IMMMMMM1 :t7.
	# .;Y. ;$MMMMMM9. :tc.
	# vY. .. .nMMM@MMU. ;1v.
	# i7i ... .#MM@M@C. .....:71i
	# it: .... $MMM@9;.,i;;;i,;tti
	# :t7. ..... 0MMMWv.,iii:::,,;St.
	# .nC. ..... IMMMQ..,::::::,.,czX.
	# .ct: ....... .ZMMMI..,:::::::,,:76Y.
	# c2: ......,i..Y$M@t..:::::::,,..inZY
	# vov ......:ii..c$MBc..,,,,,,,,,,..iI9i
	# i9Y ......iii:..7@MA,..,,,,,,,,,....;AA:
	# iIS. ......:ii::..;@MI....,............;Ez.
	# .I9. ......:i::::...8M1..................C0z.
	# .z9; ......:i::::,.. .i:...................zWX.
	# vbv ......,i::::,,. ................. :AQY
	# c6Y. .,...,::::,,..:t0@@QY. ................ :8bi
	# :6S. ..,,...,:::,,,..EMMMMMMI. ............... .;bZ,
	# :6o, .,,,,..:::,,,..i#MMMMMM#v................. YW2.
	# .n8i ..,,,,,,,::,,,,.. tMMMMM@C:.................. .1Wn
	# 7Uc. .:::,,,,,::,,,,.. i1t;,..................... .UEi
	# 7C...::::::::::::,,,,.. .................... vSi.
	# ;1;...,,::::::,......... .................. Yz:
	# v97,......... .voC.
	# izAotX7777777777777777777777777777777777777777Y7n92:
	# .;CoIIIIIUAA666666699999ZZZZZZZZZZZZZZZZZZZZ6ov.
	#
	# !!! ATTENTION !!!
	# DO NOT EDIT THIS FILE! THIS FILE CONTAINS THE DEFAULT VALUES FOR THE CON-
	# FIGURATION! EDIT YOUR SECRET FILE (either prod.secret.exs, dev.secret.exs).
	#
	# This file is responsible for configuring your application
	# and its dependencies with the aid of the Mix.Config module.
	#
	# This configuration file is loaded before any dependency and
	# is restricted to this project.
	use Mix.Config

	# General application configuration
	config :pleroma, ecto_repos: [Pleroma.Repo]

	config :pleroma, Pleroma.Repo,
	types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil

	config :pleroma, Pleroma.Captcha,
	enabled: true,
	seconds_valid: 300,
	method: Pleroma.Captcha.Native

	config :pleroma, Pleroma.Captcha.Kocaptcha, endpoint: "https://captcha.kotobank.ch"

	# Upload configuration
	config :pleroma, Pleroma.Upload,
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: false,
	proxy_remote: false,
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	],
	filename_display_max_length: 30,
	default_description: nil

	config :pleroma, Pleroma.Uploaders.Local, uploads: "uploads"

	config :pleroma, Pleroma.Uploaders.S3,
	bucket: nil,
	streaming_enabled: true,
	public_endpoint: "https://s3.amazonaws.com"

	config :pleroma, :emoji,
	shortcode_globs: ["/emoji/custom/*/.png"],
	pack_extensions: [".png", ".gif"],
	groups: [
	Custom: ["/emoji/.png", "/emoji//.png"]
	],
	default_manifest: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json",
	shared_pack_cache_seconds_per_file: 60

	config :pleroma, :uri_schemes,
	valid_schemes: [
	"https",
	"http",
	"dat",
	"dweb",
	"gopher",
	"hyper",
	"ipfs",
	"ipns",
	"irc",
	"ircs",
	"magnet",
	"mailto",
	"mumble",
	"ssb",
	"xmpp"
	]

	websocket_config = [
	path: "/websocket",
	serializer: [
	{Phoenix.Socket.V1.JSONSerializer, "~> 1.0.0"},
	{Phoenix.Socket.V2.JSONSerializer, "~> 2.0.0"}
	],
	timeout: 60_000,
	transport_log: false,
	compress: false
	]

	# Configures the endpoint
	config :pleroma, Pleroma.Web.Endpoint,
	instrumenters: [Pleroma.Web.Endpoint.Instrumenter],
	url: [host: "localhost"],
	http: [
	ip: {127, 0, 0, 1},
	dispatch: [
	{:_,
	[
	{"/api/fedsocket/v1", Pleroma.Web.FedSockets.IncomingHandler, []},
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, websocket_config}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	],
	protocol: "https",
	secret_key_base: "aK4Abxf29xU9TTDKre9coZPUgevcVCFQJe/5xP/7Lt4BEif6idBIbjupVbOrbKxl",
	signing_salt: "CqaoopA2",
	render_errors: [view: Pleroma.Web.ErrorView, accepts: ~w(json)],
	pubsub: [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2],
	secure_cookie_flag: true,
	extra_cookie_attrs: [
	"SameSite=Lax"
	]

	config :pleroma, :fed_sockets,
	enabled: false,
	connection_duration: :timer.hours(8),
	rejection_duration: :timer.minutes(15),
	fed_socket_fetches: [
	default: 12_000,
	interval: 3_000,
	lazy: false
	]

	# Configures Elixir's Logger
	config :logger, :console,
	level: :debug,
	format: "\n$time $metadata[$level] $message\n",
	metadata: [:request_id]

	config :logger, :ex_syslogger,
	level: :debug,
	ident: "pleroma",
	format: "$metadata[$level] $message",
	metadata: [:request_id]

	config :quack,
	level: :warn,
	meta: [:all],
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"

	config :mime, :types, %{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"application/jrd+json" => ["jrd+json"],
	"application/activity+json" => ["activity+json"],
	"application/ld+json" => ["activity+json"]
	}

	config :tesla, adapter: Tesla.Adapter.Hackney

	# Configures http settings, upstream proxy etc.
	config :pleroma, :http,
	proxy_url: nil,
	send_user_agent: true,
	user_agent: :default,
	adapter: []

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "Pleroma: An efficient and flexible fediverse server",
	background_image: "/images/city.jpg",
	instance_thumbnail: "/instance/thumbnail.jpeg",
	limit: 5_000,
	description_limit: 5_000,
	chat_limit: 5_000,
	remote_limit: 100_000,
	upload_limit: 16_000_000,
	avatar_upload_limit: 2_000_000,
	background_upload_limit: 4_000_000,
	banner_upload_limit: 4_000_000,
	poll_limits: %{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 365 * 24 * 60 * 60
	},
	registrations_open: true,
	invites_enabled: false,
	account_activation_required: false,
	account_approval_required: false,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	federation_publisher_modules: [
	Pleroma.Web.ActivityPub.Publisher
	],
	allow_relay: true,
	public: true,
	quarantined_instances: [],
	static_dir: "instance/static/",
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	],
	autofollowed_nicknames: [],
	max_pinned_statuses: 1,
	attachment_links: false,
	max_report_comment_size: 1000,
	safe_dm_mentions: false,
	healthcheck: false,
	remote_post_retention_days: 90,
	skip_thread_containment: true,
	limit_to_local_content: :unauthenticated,
	user_bio_length: 5000,
	user_name_length: 100,
	max_account_fields: 10,
	max_remote_account_fields: 20,
	account_field_name_length: 512,
	account_field_value_length: 2048,
	registration_reason_length: 500,
	external_user_synchronization: true,
	extended_nickname_format: true,
	cleanup_attachments: false,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 5,
	length: 16
	]
	],
	show_reactions: true

	config :pleroma, :welcome,
	direct_message: [
	enabled: false,
	sender_nickname: nil,
	message: nil
	],
	chat_message: [
	enabled: false,
	sender_nickname: nil,
	message: nil
	],
	email: [
	enabled: false,
	sender: nil,
	subject: "Welcome to <%= instance_name %>",
	html: "Welcome to <%= instance_name %>",
	text: "Welcome to <%= instance_name %>"
	]

	config :pleroma, :feed,
	post_title: %{
	max_length: 100,
	omission: "..."
	}

	config :pleroma, :markup,
	# XXX - unfortunately, inline images must be enabled by default right now, because
	# of custom emoji. Issue #275 discusses defanging that somehow.
	allow_inline_images: true,
	allow_headings: false,
	allow_tables: false,
	allow_fonts: false,
	scrub_policy: [
	Pleroma.HTML.Scrubber.Default,
	Pleroma.HTML.Transform.MediaProxy
	]

	config :pleroma, :frontend_configurations,
	pleroma_fe: %{
	alwaysShowSubjectInput: true,
	background: "/images/city.jpg",
	collapseMessageWithSubject: false,
	disableChat: false,
	greentext: false,
	hideFilteredStatuses: false,
	hideMutedPosts: false,
	hidePostStats: false,
	hideSitename: false,
	hideUserStats: false,
	loginMethod: "password",
	logo: "/static/logo.png",
	logoMargin: ".1em",
	logoMask: true,
	minimalScopesMode: false,
	noAttachmentLinks: false,
	nsfwCensorImage: "",
	postContentType: "text/plain",
	redirectRootLogin: "/main/friends",
	redirectRootNoLogin: "/main/all",
	scopeCopy: true,
	sidebarRight: false,
	showFeaturesPanel: true,
	showInstanceSpecificPanel: false,
	subjectLineBehavior: "email",
	theme: "pleroma-dark",
	webPushNotifications: false
	},
	masto_fe: %{
	showInstanceSpecificPanel: true
	}

	config :pleroma, :assets,
	mascots: [
	pleroma_fox_tan: %{
	url: "/images/pleroma-fox-tan-smol.png",
	mime_type: "image/png"
	},
	pleroma_fox_tan_shy: %{
	url: "/images/pleroma-fox-tan-shy.png",
	mime_type: "image/png"
	}
	],
	default_mascot: :pleroma_fox_tan

	config :pleroma, :manifest,
	icons: [
	%{
	src: "/static/logo.png",
	type: "image/png"
	}
	],
	theme_color: "#282c37",
	background_color: "#191b22"

	config :pleroma, :activitypub,
	unfollow_blocked: true,
	outgoing_blocks: true,
	follow_handshake_timeout: 500,
	note_replies_output_limit: 5,
	sign_object_fetches: true,
	authorized_fetch_mode: false

	config :pleroma, :streamer,
	workers: 3,
	overflow_workers: 2

	config :pleroma, :user, deny_follow_blocked: true

	config :pleroma, :mrf_normalize_markup, scrub_policy: Pleroma.HTML.Scrubber.Default

	config :pleroma, :mrf_rejectnonpublic,
	allow_followersonly: false,
	allow_direct: false

	config :pleroma, :mrf_hellthread,
	delist_threshold: 10,
	reject_threshold: 20

	config :pleroma, :mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	followers_only: [],
	accept: [],
	avatar_removal: [],
	banner_removal: [],
	reject_deletes: []

	config :pleroma, :mrf_keyword,
	reject: [],
	federated_timeline_removal: [],
	replace: []

	config :pleroma, :mrf_subchain, match_actor: %{}

	config :pleroma, :mrf_activity_expiration, days: 365

	config :pleroma, :mrf_vocabulary,
	accept: [],
	reject: []

	# threshold of 7 days
	config :pleroma, :mrf_object_age,
	threshold: 604_800,
	actions: [:delist, :strip_followers]

	config :pleroma, :rich_media,
	enabled: true,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"],
	parsers: [
	Pleroma.Web.RichMedia.Parsers.TwitterCard,
	Pleroma.Web.RichMedia.Parsers.OEmbed
	],
	failure_backoff: 60_000,
	ttl_setters: [Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl]

	config :pleroma, :media_proxy,
	enabled: false,
	invalidation: [
	enabled: false,
	provider: Pleroma.Web.MediaProxy.Invalidation.Script
	],
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	# Note: max_read_duration defaults to Pleroma.ReverseProxy.max_read_duration_default/1
	max_read_duration: 30_000,
	http: [
	follow_redirect: true,
	pool: :media
	]
	],
	whitelist: []

	config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Http,
	method: :purge,
	headers: [],
	options: []

	config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Script, script_path: nil

	# Note: media preview proxy depends on media proxy to be enabled
	config :pleroma, :media_preview_proxy,
	enabled: false,
	thumbnail_max_width: 600,
	thumbnail_max_height: 600,
	image_quality: 85,
	min_content_length: 100 * 1024

	config :pleroma, :chat, enabled: true

	config :phoenix, :format_encoders, json: Jason

	config :phoenix, :json_library, Jason

	config :phoenix, :filter_parameters, ["password", "confirm"]

	config :pleroma, :gopher,
	enabled: false,
	ip: {0, 0, 0, 0},
	port: 9999

	config :pleroma, Pleroma.Web.Metadata,
	providers: [
	Pleroma.Web.Metadata.Providers.OpenGraph,
	Pleroma.Web.Metadata.Providers.TwitterCard
	],
	unfurl_nsfw: false

	config :pleroma, Pleroma.Web.Preload,
	providers: [
	Pleroma.Web.Preload.Providers.Instance
	]

	config :pleroma, :http_security,
	enabled: true,
	sts: false,
	sts_max_age: 31_536_000,
	ct_max_age: 2_592_000,
	referrer_policy: "same-origin"

	config :cors_plug,
	max_age: 86_400,
	methods: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"],
	expose: [
	"Link",
	"X-RateLimit-Reset",
	"X-RateLimit-Limit",
	"X-RateLimit-Remaining",
	"X-Request-Id",
	"Idempotency-Key"
	],
	credentials: true,
	headers: ["Authorization", "Content-Type", "Idempotency-Key"]

	config :pleroma, Pleroma.User,
	restricted_nicknames: [
	".well-known",
	"~",
	"about",
	"activities",
	"api",
	"auth",
	"check_password",
	"dev",
	"friend-requests",
	"inbox",
	"internal",
	"main",
	"media",
	"nodeinfo",
	"notice",
	"oauth",
	"objects",
	"ostatus_subscribe",
	"pleroma",
	"proxy",
	"push",
	"registration",
	"relay",
	"settings",
	"status",
	"tag",
	"user-search",
	"user_exists",
	"users",
	"web",
	"verify_credentials",
	"update_credentials",
	"relationships",
	"search",
	"confirmation_resend",
	"mfa"
	],
	email_blacklist: []

	config :pleroma, Oban,
	repo: Pleroma.Repo,
	log: false,
	queues: [
	activity_expiration: 10,
	token_expiration: 5,
	federator_incoming: 50,
	federator_outgoing: 50,
	ingestion_queue: 50,
	web_push: 50,
	mailer: 10,
	transmogrifier: 20,
	scheduled_activities: 10,
	background: 5,
	remote_fetcher: 2,
	attachments_cleanup: 5,
	new_users_digest: 1
	],
	plugins: [Oban.Plugins.Pruner],
	crontab: [
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker}
	]

	config :pleroma, :workers,
	retries: [
	federator_incoming: 5,
	federator_outgoing: 5
	]

	config :pleroma, Pleroma.Formatter,
	class: false,
	rel: "ugc",
	new_window: false,
	truncate: false,
	strip_prefix: false,
	extra: true,
	validate_tld: :no_scheme

	config :pleroma, :ldap,
	enabled: System.get_env("LDAP_ENABLED") == "true",
	host: System.get_env("LDAP_HOST") \|\| "localhost",
	port: String.to_integer(System.get_env("LDAP_PORT") \|\| "389"),
	ssl: System.get_env("LDAP_SSL") == "true",
	sslopts: [],
	tls: System.get_env("LDAP_TLS") == "true",
	tlsopts: [],
	base: System.get_env("LDAP_BASE") \|\| "dc=example,dc=com",
	uid: System.get_env("LDAP_UID") \|\| "cn"

	config :esshd,
	enabled: false

	oauth_consumer_strategies =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(&hd(String.split(&1, ":")))

	ueberauth_providers =
	for strategy <- oauth_consumer_strategies do
	strategy_module_name = "Elixir.Ueberauth.Strategy.#{String.capitalize(strategy)}"
	strategy_module = String.to_atom(strategy_module_name)
	{String.to_atom(strategy), {strategy_module, [callback_params: ["state"]]}}
	end

	config :ueberauth,
	Ueberauth,
	base_path: "/oauth",
	providers: ueberauth_providers

	config :pleroma,
	:auth,
	enforce_oauth_admin_scope_usage: true,
	oauth_consumer_strategies: oauth_consumer_strategies

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Sendmail, enabled: false

	config :pleroma, Pleroma.Emails.UserEmail,
	logo: nil,
	styling: %{
	link_color: "#d8a070",
	background_color: "#2C3645",
	content_background_color: "#1B2635",
	header_color: "#d8a070",
	text_color: "#b9b9ba",
	text_muted_color: "#b9b9ba"
	}

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: false

	config :prometheus, Pleroma.Web.Endpoint.MetricsExporter, path: "/api/pleroma/app_metrics"

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 25,
	total_user_limit: 300,
	enabled: true

	config :pleroma, :email_notifications,
	digest: %{
	active: false,
	interval: 7,
	inactivity_threshold: 7
	}

	config :pleroma, :oauth2,
	token_expires_in: 600,
	issue_new_refresh_token: true,
	clean_expired_tokens: false

	config :pleroma, :database, rum_enabled: false

	config :pleroma, :env, Mix.env()

	config :http_signatures,
	adapter: Pleroma.Signature

	config :pleroma, :rate_limit,
	authentication: {60_000, 15},
	timeline: {500, 3},
	search: [{1000, 10}, {1000, 30}],
	app_account_creation: {1_800_000, 25},
	relations_actions: {10_000, 10},
	relation_id_action: {60_000, 2},
	statuses_actions: {10_000, 15},
	status_id_action: {60_000, 3},
	password_reset: {1_800_000, 5},
	account_confirmation_resend: {8_640_000, 5},
	ap_routes: {60_000, 15}

	config :pleroma, Pleroma.Workers.PurgeExpiredActivity, enabled: true, min_lifetime: 600

	config :pleroma, Pleroma.Plugs.RemoteIp, enabled: true

	config :pleroma, :static_fe, enabled: false

	# Example of frontend configuration
	# This example will make us serve the primary frontend from the
	# frontends directory within your `:pleroma, :instance, static_dir`.
	# e.g., instance/static/frontends/pleroma/develop/
	#
	# With no frontend configuration, the bundled files from the `static` directory will
	# be used.
	#
	# config :pleroma, :frontends,
	# primary: %{"name" => "pleroma-fe", "ref" => "develop"},
	# admin: %{"name" => "admin-fe", "ref" => "stable"},
	# available: %{...}

	config :pleroma, :frontends,
	available: %{
	"kenoma" => %{
	"name" => "kenoma",
	"git" => "https://git.pleroma.social/lambadalambda/kenoma",
	"build_url" =>
	"https://git.pleroma.social/lambadalambda/kenoma/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "master"
	},
	"pleroma-fe" => %{
	"name" => "pleroma-fe",
	"git" => "https://git.pleroma.social/pleroma/pleroma-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/pleroma-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"fedi-fe" => %{
	"name" => "fedi-fe",
	"git" => "https://git.pleroma.social/pleroma/fedi-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/fedi-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "master"
	},
	"admin-fe" => %{
	"name" => "admin-fe",
	"git" => "https://git.pleroma.social/pleroma/admin-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/admin-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"soapbox-fe" => %{
	"name" => "soapbox-fe",
	"git" => "https://gitlab.com/soapbox-pub/soapbox-fe",
	"build_url" =>
	"https://gitlab.com/soapbox-pub/soapbox-fe/-/jobs/artifacts/${ref}/download?job=build-production",
	"ref" => "v1.0.0",
	"build_dir" => "static"
	}
	}

	config :pleroma, :web_cache_ttl,
	activity_pub: nil,
	activity_pub_question: 30_000

	config :pleroma, :modules, runtime_dir: "instance/modules"

	config :pleroma, configurable_from_database: false

	config :pleroma, Pleroma.Repo,
	parameters: [gin_fuzzy_search_limit: "500"],
	prepare: :unnamed

	config :pleroma, :connections_pool,
	reclaim_multiplier: 0.1,
	connection_acquisition_wait: 250,
	connection_acquisition_retries: 5,
	max_connections: 250,
	max_idle_time: 30_000,
	retry: 0,
	connect_timeout: 5_000

	config :pleroma, :pools,
	federation: [
	size: 50,
	max_waiting: 10,
	recv_timeout: 10_000
	],
	media: [
	size: 50,
	max_waiting: 20,
	recv_timeout: 15_000
	],
	upload: [
	size: 25,
	max_waiting: 5,
	recv_timeout: 15_000
	],
	default: [
	size: 10,
	max_waiting: 2,
	recv_timeout: 5_000
	]

	config :pleroma, :hackney_pools,
	federation: [
	max_connections: 50,
	timeout: 150_000
	],
	media: [
	max_connections: 50,
	timeout: 150_000
	],
	upload: [
	max_connections: 25,
	timeout: 300_000
	]

	private_instance? = :if_instance_is_private

	config :pleroma, :restrict_unauthenticated,
	timelines: %{local: private_instance?, federated: private_instance?},
	profiles: %{local: private_instance?, remote: private_instance?},
	activities: %{local: private_instance?, remote: private_instance?}

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: false

	config :pleroma, :mrf,
	policies: Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy,
	transparency: true,
	transparency_exclusions: []

	config :tzdata, :http_client, Pleroma.HTTP.Tzdata

	config :ex_aws, http_client: Pleroma.HTTP.ExAws

	-config :web_push_encryption, http_client: Pleroma.HTTP
	+config :web_push_encryption, http_client: Pleroma.HTTP.WebPush

	config :pleroma, :instances_favicons, enabled: false

	config :floki, :html_parser, Floki.HTMLParser.FastHtml

	config :pleroma, Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.PleromaAuthenticator

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env()}.exs"
	diff --git a/config/description.exs b/config/description.exs
	index ac3dfbb2b..6fa78a5d1 100644
	--- a/config/description.exs
	+++ b/config/description.exs
	@@ -1,3709 +1,3710 @@
	use Mix.Config
	alias Pleroma.Docs.Generator

	websocket_config = [
	path: "/websocket",
	serializer: [
	{Phoenix.Socket.V1.JSONSerializer, "~> 1.0.0"},
	{Phoenix.Socket.V2.JSONSerializer, "~> 2.0.0"}
	],
	timeout: 60_000,
	transport_log: false,
	compress: false
	]

	installed_frontend_options = [
	%{
	key: "name",
	label: "Name",
	type: :string,
	description:
	"Name of the installed frontend. Valid config must include both `Name` and `Reference` values."
	},
	%{
	key: "ref",
	label: "Reference",
	type: :string,
	description:
	"Reference of the installed frontend to be used. Valid config must include both `Name` and `Reference` values."
	}
	]

	frontend_options = [
	%{
	key: "name",
	label: "Name",
	type: :string,
	description: "Name of the frontend."
	},
	%{
	key: "ref",
	label: "Reference",
	type: :string,
	description: "Reference of the frontend to be used."
	},
	%{
	key: "git",
	+ label: "Git Repository URL",
	type: :string,
	description: "URL of the git repository of the frontend"
	},
	%{
	key: "build_url",
	+ label: "Build URL",
	type: :string,
	description:
	"Either an url to a zip file containing the frontend or a template to build it by inserting the `ref`. The string `${ref}` will be replaced by the configured `ref`.",
	example: "https://some.url/builds/${ref}.zip"
	},
	%{
	key: "build_dir",
	+ label: "Build directory",
	type: :string,
	description: "The directory inside the zip file "
	}
	]

	config :pleroma, :config_description, [
	%{
	group: :pleroma,
	key: Pleroma.Upload,
	type: :group,
	description: "Upload general settings",
	children: [
	%{
	key: :uploader,
	type: :module,
	description: "Module which will be used for uploads",
	suggestions: {:list_behaviour_implementations, Pleroma.Uploaders.Uploader}
	},
	%{
	key: :filters,
	type: {:list, :module},
	description:
	"List of filter modules for uploads. Module names are shortened (removed leading `Pleroma.Upload.Filter.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Upload.Filter}
	},
	%{
	key: :link_name,
	type: :boolean,
	description:
	"If enabled, a name parameter will be added to the URL of the upload. For example `https://instance.tld/media/imagehash.png?name=realname.png`."
	},
	%{
	key: :base_url,
	label: "Base URL",
	type: :string,
	description: "Base URL for the uploads, needed if you use CDN",
	suggestions: [
	"https://cdn-host.com"
	]
	},
	%{
	key: :proxy_remote,
	type: :boolean,
	description:
	"If enabled, requests to media stored using a remote uploader will be proxied instead of being redirected"
	},
	%{
	key: :proxy_opts,
	label: "Proxy Options",
	type: :keyword,
	description: "Options for Pleroma.ReverseProxy",
	suggestions: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	http: [
	follow_redirect: true,
	pool: :media
	]
	],
	children: [
	%{
	key: :redirect_on_failure,
	type: :boolean,
	description:
	"Redirects the client to the real remote URL if there's any HTTP errors. " <>
	"Any error during body processing will not be redirected as the response is chunked."
	},
	%{
	key: :max_body_length,
	type: :integer,
	description:
	"Limits the content length to be approximately the " <>
	"specified length. It is validated with the `content-length` header and also verified when proxying."
	},
	%{
	key: :http,
	label: "HTTP",
	type: :keyword,
	description: "HTTP options",
	children: [
	%{
	key: :adapter,
	type: :keyword,
	description: "Adapter specific options",
	children: [
	%{
	key: :ssl_options,
	type: :keyword,
	label: "SSL Options",
	description: "SSL options for HTTP adapter",
	children: [
	%{
	key: :versions,
	type: {:list, :atom},
	description: "List of TLS versions to use",
	suggestions: [:tlsv1, ":tlsv1.1", ":tlsv1.2"]
	}
	]
	}
	]
	},
	%{
	key: :proxy_url,
	label: "Proxy URL",
	type: [:string, :tuple],
	description: "Proxy URL",
	suggestions: ["127.0.0.1:8123", {:socks5, :localhost, 9050}]
	}
	]
	}
	]
	},
	%{
	key: :filename_display_max_length,
	type: :integer,
	description: "Set max length of a filename to display. 0 = no limit. Default: 30"
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Uploaders.Local,
	type: :group,
	description: "Local uploader-related settings",
	children: [
	%{
	key: :uploads,
	type: :string,
	description: "Path where user's uploads will be saved",
	suggestions: [
	"uploads"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Uploaders.S3,
	type: :group,
	description: "S3 uploader-related settings",
	children: [
	%{
	key: :bucket,
	type: :string,
	description: "S3 bucket",
	suggestions: [
	"bucket"
	]
	},
	%{
	key: :bucket_namespace,
	type: :string,
	description: "S3 bucket namespace",
	suggestions: ["pleroma"]
	},
	%{
	key: :public_endpoint,
	type: :string,
	description: "S3 endpoint",
	suggestions: ["https://s3.amazonaws.com"]
	},
	%{
	key: :truncated_namespace,
	type: :string,
	description:
	"If you use S3 compatible service such as Digital Ocean Spaces or CDN, set folder name or \"\" etc." <>
	" For example, when using CDN to S3 virtual host format, set \"\". At this time, write CNAME to CDN in public_endpoint."
	},
	%{
	key: :streaming_enabled,
	type: :boolean,
	description:
	"Enable streaming uploads, when enabled the file will be sent to the server in chunks as it's being read. This may be unsupported by some providers, try disabling this if you have upload problems."
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Upload.Filter.Mogrify,
	type: :group,
	description: "Uploads mogrify filter settings",
	children: [
	%{
	key: :args,
	type: [:string, {:list, :string}, {:list, :tuple}],
	description:
	"List of actions for the mogrify command. It's possible to add self-written settings as string. " <>
	"For example `auto-orient, strip, {\"resize\", \"3840x1080>\"}` value will be parsed into valid list of the settings.",
	suggestions: [
	"strip",
	"auto-orient",
	{"implode", "1"}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Upload.Filter.AnonymizeFilename,
	type: :group,
	description: "Filter replaces the filename of the upload",
	children: [
	%{
	key: :text,
	type: :string,
	description:
	"Text to replace filenames in links. If no setting, {random}.extension will be used. You can get the original" <>
	" filename extension by using {extension}, for example custom-file-name.{extension}.",
	suggestions: [
	"custom-file-name.{extension}"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :fed_sockets,
	type: :group,
	description: "Websocket based federation",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enable FedSockets"
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.Mailer,
	type: :group,
	description: "Mailer-related settings",
	children: [
	%{
	key: :adapter,
	type: :module,
	description:
	"One of the mail adapters listed in [Swoosh readme](https://github.com/swoosh/swoosh#adapters)," <>
	" or Swoosh.Adapters.Local for in-memory mailbox",
	suggestions: [
	Swoosh.Adapters.SMTP,
	Swoosh.Adapters.Sendgrid,
	Swoosh.Adapters.Sendmail,
	Swoosh.Adapters.Mandrill,
	Swoosh.Adapters.Mailgun,
	Swoosh.Adapters.Mailjet,
	Swoosh.Adapters.Postmark,
	Swoosh.Adapters.SparkPost,
	Swoosh.Adapters.AmazonSES,
	Swoosh.Adapters.Dyn,
	Swoosh.Adapters.SocketLabs,
	Swoosh.Adapters.Gmail,
	Swoosh.Adapters.Local
	]
	},
	%{
	key: :enabled,
	type: :boolean,
	description: "Allow/disallow send emails"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :relay,
	type: :string,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting",
	suggestions: ["smtp.gmail.com"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :username,
	type: :string,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting",
	suggestions: ["pleroma"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :password,
	type: :string,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting",
	suggestions: ["password"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :ssl,
	label: "SSL",
	type: :boolean,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :tls,
	label: "TLS",
	type: :atom,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting",
	suggestions: [:always, :never, :if_available]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :auth,
	type: :atom,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting",
	suggestions: [:always, :never, :if_available]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :port,
	type: :integer,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting",
	suggestions: [1025]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :retries,
	type: :integer,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting",
	suggestions: [5]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :no_mx_lookups,
	label: "No MX lookups",
	type: :boolean,
	description: "`Swoosh.Adapters.SMTP` adapter specific setting"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendgrid},
	key: :api_key,
	label: "API key",
	type: :string,
	description: "`Swoosh.Adapters.Sendgrid` adapter specific setting",
	suggestions: ["my-api-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :cmd_path,
	type: :string,
	description: "`Swoosh.Adapters.Sendmail` adapter specific setting",
	suggestions: ["/usr/bin/sendmail"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :cmd_args,
	type: :string,
	description: "`Swoosh.Adapters.Sendmail` adapter specific setting",
	suggestions: ["-N delay,failure,success"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :qmail,
	type: :boolean,
	description: "`Swoosh.Adapters.Sendmail` adapter specific setting"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mandrill},
	key: :api_key,
	label: "API key",
	type: :string,
	description: "`Swoosh.Adapters.Mandrill` adapter specific setting",
	suggestions: ["my-api-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailgun},
	key: :api_key,
	label: "API key",
	type: :string,
	description: "`Swoosh.Adapters.Mailgun` adapter specific setting",
	suggestions: ["my-api-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailgun},
	key: :domain,
	type: :string,
	description: "`Swoosh.Adapters.Mailgun` adapter specific setting",
	suggestions: ["pleroma.com"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailjet},
	key: :api_key,
	label: "API key",
	type: :string,
	description: "`Swoosh.Adapters.Mailjet` adapter specific setting",
	suggestions: ["my-api-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailjet},
	key: :secret,
	type: :string,
	description: "`Swoosh.Adapters.Mailjet` adapter specific setting",
	suggestions: ["my-secret-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Postmark},
	key: :api_key,
	label: "API key",
	type: :string,
	description: "`Swoosh.Adapters.Postmark` adapter specific setting",
	suggestions: ["my-api-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SparkPost},
	key: :api_key,
	label: "API key",
	type: :string,
	description: "`Swoosh.Adapters.SparkPost` adapter specific setting",
	suggestions: ["my-api-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SparkPost},
	key: :endpoint,
	type: :string,
	description: "`Swoosh.Adapters.SparkPost` adapter specific setting",
	suggestions: ["https://api.sparkpost.com/api/v1"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :region,
	type: :string,
	description: "`Swoosh.Adapters.AmazonSES` adapter specific setting",
	suggestions: ["us-east-1", "us-east-2"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :access_key,
	type: :string,
	description: "`Swoosh.Adapters.AmazonSES` adapter specific setting",
	suggestions: ["aws-access-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :secret,
	type: :string,
	description: "`Swoosh.Adapters.AmazonSES` adapter specific setting",
	suggestions: ["aws-secret-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Dyn},
	key: :api_key,
	label: "API key",
	type: :string,
	description: "`Swoosh.Adapters.Dyn` adapter specific setting",
	suggestions: ["my-api-key"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SocketLabs},
	key: :server_id,
	type: :string,
	description: "`Swoosh.Adapters.SocketLabs` adapter specific setting"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SocketLabs},
	key: :api_key,
	label: "API key",
	type: :string,
	description: "`Swoosh.Adapters.SocketLabs` adapter specific setting"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Gmail},
	key: :access_token,
	type: :string,
	description: "`Swoosh.Adapters.Gmail` adapter specific setting"
	}
	]
	},
	%{
	group: :swoosh,
	type: :group,
	description: "`Swoosh.Adapters.Local` adapter specific settings",
	children: [
	%{
	group: {:subgroup, Swoosh.Adapters.Local},
	key: :serve_mailbox,
	type: :boolean,
	description: "Run the preview server together as part of your app"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Local},
	key: :preview_port,
	type: :integer,
	description: "The preview server port",
	suggestions: [4001]
	}
	]
	},
	%{
	group: :pleroma,
	key: :uri_schemes,
	label: "URI Schemes",
	type: :group,
	description: "URI schemes related settings",
	children: [
	%{
	key: :valid_schemes,
	type: {:list, :string},
	description: "List of the scheme part that is considered valid to be an URL",
	suggestions: [
	"https",
	"http",
	"dat",
	"dweb",
	"gopher",
	"hyper",
	"ipfs",
	"ipns",
	"irc",
	"ircs",
	"magnet",
	"mailto",
	"mumble",
	"ssb",
	"xmpp"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :instance,
	type: :group,
	description: "Instance-related settings",
	children: [
	%{
	key: :name,
	type: :string,
	description: "Name of the instance",
	suggestions: [
	"Pleroma"
	]
	},
	%{
	key: :email,
	label: "Admin Email Address",
	type: :string,
	description: "Email used to reach an Administrator/Moderator of the instance",
	suggestions: [
	"email@example.com"
	]
	},
	%{
	key: :notify_email,
	label: "Sender Email Address",
	type: :string,
	description: "Envelope FROM address for mail sent via Pleroma",
	suggestions: [
	"notify@example.com"
	]
	},
	%{
	key: :description,
	type: :string,
	description:
	"The instance's description. It can be seen in nodeinfo and `/api/v1/instance`",
	suggestions: [
	"Very cool instance"
	]
	},
	%{
	key: :limit,
	type: :integer,
	description: "Posts character limit (CW/Subject included in the counter)",
	suggestions: [
	5_000
	]
	},
	%{
	key: :chat_limit,
	type: :integer,
	description: "Character limit of the instance chat messages",
	suggestions: [
	5_000
	]
	},
	%{
	key: :remote_limit,
	type: :integer,
	description: "Hard character limit beyond which remote posts will be dropped",
	suggestions: [
	100_000
	]
	},
	%{
	key: :upload_limit,
	type: :integer,
	description: "File size limit of uploads (except for avatar, background, banner)",
	suggestions: [
	16_000_000
	]
	},
	%{
	key: :avatar_upload_limit,
	type: :integer,
	description: "File size limit of user's profile avatars",
	suggestions: [
	2_000_000
	]
	},
	%{
	key: :background_upload_limit,
	type: :integer,
	description: "File size limit of user's profile backgrounds",
	suggestions: [
	4_000_000
	]
	},
	%{
	key: :banner_upload_limit,
	type: :integer,
	description: "File size limit of user's profile banners",
	suggestions: [
	4_000_000
	]
	},
	%{
	key: :poll_limits,
	type: :map,
	description: "A map with poll limits for local polls",
	suggestions: [
	%{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 31_536_000
	}
	],
	children: [
	%{
	key: :max_options,
	type: :integer,
	description: "Maximum number of options",
	suggestions: [20]
	},
	%{
	key: :max_option_chars,
	type: :integer,
	description: "Maximum number of characters per option",
	suggestions: [200]
	},
	%{
	key: :min_expiration,
	type: :integer,
	description: "Minimum expiration time (in seconds)",
	suggestions: [0]
	},
	%{
	key: :max_expiration,
	type: :integer,
	description: "Maximum expiration time (in seconds)",
	suggestions: [3600]
	}
	]
	},
	%{
	key: :registrations_open,
	type: :boolean,
	description:
	"Enable registrations for anyone. Invitations require this setting to be disabled."
	},
	%{
	key: :invites_enabled,
	type: :boolean,
	description:
	"Enable user invitations for admins (depends on `registrations_open` being disabled)"
	},
	%{
	key: :account_activation_required,
	type: :boolean,
	description: "Require users to confirm their emails before signing in"
	},
	%{
	key: :account_approval_required,
	type: :boolean,
	description: "Require users to be manually approved by an admin before signing in"
	},
	%{
	key: :federating,
	type: :boolean,
	description: "Enable federation with other instances"
	},
	%{
	key: :federation_incoming_replies_max_depth,
	label: "Fed. incoming replies max depth",
	type: :integer,
	description:
	"Max. depth of reply-to and reply activities fetching on incoming federation, to prevent out-of-memory situations while" <>
	" fetching very long threads. If set to `nil`, threads of any depth will be fetched. Lower this value if you experience out-of-memory crashes.",
	suggestions: [
	100
	]
	},
	%{
	key: :federation_reachability_timeout_days,
	label: "Fed. reachability timeout days",
	type: :integer,
	description:
	"Timeout (in days) of each external federation target being unreachable prior to pausing federating to it",
	suggestions: [
	7
	]
	},
	%{
	key: :allow_relay,
	type: :boolean,
	description: "Enable Pleroma's Relay, which makes it possible to follow a whole instance"
	},
	%{
	key: :public,
	type: :boolean,
	description:
	"Makes the client API in authenticated mode-only except for user-profiles." <>
	" Useful for disabling the Local Timeline and The Whole Known Network. " <>
	" Note: when setting to `false`, please also check `:restrict_unauthenticated` setting."
	},
	%{
	key: :quarantined_instances,
	type: {:list, :string},
	description:
	"List of ActivityPub instances where private (DMs, followers-only) activities will not be sent",
	suggestions: [
	"quarantined.com",
	"*.quarantined.com"
	]
	},
	%{
	key: :static_dir,
	type: :string,
	description: "Instance static directory",
	suggestions: [
	"instance/static/"
	]
	},
	%{
	key: :allowed_post_formats,
	type: {:list, :string},
	description: "MIME-type list of formats allowed to be posted (transformed into HTML)",
	suggestions: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	]
	},
	%{
	key: :extended_nickname_format,
	type: :boolean,
	description:
	"Enable to use extended local nicknames format (allows underscores/dashes)." <>
	" This will break federation with older software for theses nicknames."
	},
	%{
	key: :cleanup_attachments,
	type: :boolean,
	description: """
	Enable to remove associated attachments when status is removed.
	This will not affect duplicates and attachments without status.
	Enabling this will increase load to database when deleting statuses on larger instances.
	"""
	},
	%{
	key: :max_pinned_statuses,
	type: :integer,
	description: "The maximum number of pinned statuses. 0 will disable the feature.",
	suggestions: [
	0,
	1,
	3
	]
	},
	%{
	key: :autofollowed_nicknames,
	type: {:list, :string},
	description:
	"Set to nicknames of (local) users that every new user should automatically follow",
	suggestions: [
	"lain",
	"kaniini",
	"lanodan",
	"rinpatch"
	]
	},
	%{
	key: :attachment_links,
	type: :boolean,
	description: "Enable to automatically add attachment link text to statuses"
	},
	%{
	key: :max_report_comment_size,
	type: :integer,
	description: "The maximum size of the report comment. Default: 1000.",
	suggestions: [
	1_000
	]
	},
	%{
	key: :safe_dm_mentions,
	label: "Safe DM mentions",
	type: :boolean,
	description:
	"If enabled, only mentions at the beginning of a post will be used to address people in direct messages." <>
	" This is to prevent accidental mentioning of people when talking about them (e.g. \"@admin please keep an eye on @bad_actor\")." <>
	" Default: disabled"
	},
	%{
	key: :healthcheck,
	type: :boolean,
	description: "If enabled, system data will be shown on `/api/pleroma/healthcheck`"
	},
	%{
	key: :remote_post_retention_days,
	type: :integer,
	description:
	"The default amount of days to retain remote posts when pruning the database",
	suggestions: [
	90
	]
	},
	%{
	key: :user_bio_length,
	type: :integer,
	description: "A user bio maximum length. Default: 5000.",
	suggestions: [
	5_000
	]
	},
	%{
	key: :user_name_length,
	type: :integer,
	description: "A user name maximum length. Default: 100.",
	suggestions: [
	100
	]
	},
	%{
	key: :skip_thread_containment,
	type: :boolean,
	description: "Skip filtering out broken threads. Default: enabled."
	},
	%{
	key: :limit_to_local_content,
	type: {:dropdown, :atom},
	description:
	"Limit unauthenticated users to search for local statutes and users only. Default: `:unauthenticated`.",
	suggestions: [
	:unauthenticated,
	:all,
	false
	]
	},
	%{
	key: :max_account_fields,
	type: :integer,
	description: "The maximum number of custom fields in the user profile. Default: 10.",
	suggestions: [
	10
	]
	},
	%{
	key: :max_remote_account_fields,
	type: :integer,
	description:
	"The maximum number of custom fields in the remote user profile. Default: 20.",
	suggestions: [
	20
	]
	},
	%{
	key: :account_field_name_length,
	type: :integer,
	description: "An account field name maximum length. Default: 512.",
	suggestions: [
	512
	]
	},
	%{
	key: :account_field_value_length,
	type: :integer,
	description: "An account field value maximum length. Default: 2048.",
	suggestions: [
	2048
	]
	},
	%{
	key: :registration_reason_length,
	type: :integer,
	description: "Maximum registration reason length. Default: 500.",
	suggestions: [
	500
	]
	},
	%{
	key: :external_user_synchronization,
	type: :boolean,
	description: "Enabling following/followers counters synchronization for external users"
	},
	%{
	key: :multi_factor_authentication,
	type: :keyword,
	description: "Multi-factor authentication settings",
	suggestions: [
	[
	totp: [digits: 6, period: 30],
	backup_codes: [number: 5, length: 16]
	]
	],
	children: [
	%{
	key: :totp,
	label: "TOTP settings",
	type: :keyword,
	description: "TOTP settings",
	suggestions: [digits: 6, period: 30],
	children: [
	%{
	key: :digits,
	type: :integer,
	suggestions: [6],
	description:
	"Determines the length of a one-time pass-code, in characters. Defaults to 6 characters."
	},
	%{
	key: :period,
	type: :integer,
	suggestions: [30],
	description:
	"A period for which the TOTP code will be valid, in seconds. Defaults to 30 seconds."
	}
	]
	},
	%{
	key: :backup_codes,
	type: :keyword,
	description: "MFA backup codes settings",
	suggestions: [number: 5, length: 16],
	children: [
	%{
	key: :number,
	type: :integer,
	suggestions: [5],
	description: "Number of backup codes to generate."
	},
	%{
	key: :length,
	type: :integer,
	suggestions: [16],
	description:
	"Determines the length of backup one-time pass-codes, in characters. Defaults to 16 characters."
	}
	]
	}
	]
	},
	%{
	key: :instance_thumbnail,
	type: {:string, :image},
	description:
	"The instance thumbnail can be any image that represents your instance and is used by some apps or services when they display information about your instance.",
	suggestions: ["/instance/thumbnail.jpeg"]
	},
	%{
	key: :show_reactions,
	type: :boolean,
	description: "Let favourites and emoji reactions be viewed through the API."
	}
	]
	},
	%{
	group: :pleroma,
	key: :welcome,
	type: :group,
	description: "Welcome messages settings",
	children: [
	%{
	key: :direct_message,
	type: :keyword,
	descpiption: "Direct message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending a direct message to newly registered users"
	},
	%{
	key: :message,
	type: :string,
	description: "A message that will be sent to newly registered users",
	suggestions: [
	"Hi, @username! Welcome on board!"
	]
	},
	%{
	key: :sender_nickname,
	type: :string,
	description: "The nickname of the local user that sends a welcome message",
	suggestions: [
	"lain"
	]
	}
	]
	},
	%{
	key: :chat_message,
	type: :keyword,
	descpiption: "Chat message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending a chat message to newly registered users"
	},
	%{
	key: :message,
	type: :string,
	description:
	"A message that will be sent to newly registered users as a chat message",
	suggestions: [
	"Hello, welcome on board!"
	]
	},
	%{
	key: :sender_nickname,
	type: :string,
	description: "The nickname of the local user that sends a welcome chat message",
	suggestions: [
	"lain"
	]
	}
	]
	},
	%{
	key: :email,
	type: :keyword,
	descpiption: "Email message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending an email to newly registered users"
	},
	%{
	key: :sender,
	type: [:string, :tuple],
	description:
	"Email address and/or nickname that will be used to send the welcome email.",
	suggestions: [
	{"Pleroma App", "welcome@pleroma.app"}
	]
	},
	%{
	key: :subject,
	type: :string,
	description:
	"Subject of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["Welcome to <%= instance_name%>"]
	},
	%{
	key: :html,
	type: :string,
	description:
	"HTML content of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["<h1>Hello <%= user.name%>. Welcome to <%= instance_name%></h1>"]
	},
	%{
	key: :text,
	type: :string,
	description:
	"Text content of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["Hello <%= user.name%>. \n Welcome to <%= instance_name%>\n"]
	}
	]
	}
	]
	},
	%{
	group: :logger,
	type: :group,
	description: "Logger-related settings",
	children: [
	%{
	key: :backends,
	type: [:atom, :tuple, :module],
	description:
	"Where logs will be sent, :console - send logs to stdout, { ExSyslogger, :ex_syslogger } - to syslog, Quack.Logger - to Slack.",
	suggestions: [:console, {ExSyslogger, :ex_syslogger}, Quack.Logger]
	}
	]
	},
	%{
	group: :logger,
	type: :group,
	key: :ex_syslogger,
	label: "ExSyslogger",
	description: "ExSyslogger-related settings",
	children: [
	%{
	key: :level,
	type: {:dropdown, :atom},
	description: "Log level",
	suggestions: [:debug, :info, :warn, :error]
	},
	%{
	key: :ident,
	type: :string,
	description:
	"A string that's prepended to every message, and is typically set to the app name",
	suggestions: ["pleroma"]
	},
	%{
	key: :format,
	type: :string,
	description: "Default: \"$date $time [$level] $levelpad$node $metadata $message\"",
	suggestions: ["$metadata[$level] $message"]
	},
	%{
	key: :metadata,
	type: {:list, :atom},
	suggestions: [:request_id]
	}
	]
	},
	%{
	group: :logger,
	type: :group,
	key: :console,
	label: "Console Logger",
	description: "Console logger settings",
	children: [
	%{
	key: :level,
	type: {:dropdown, :atom},
	description: "Log level",
	suggestions: [:debug, :info, :warn, :error]
	},
	%{
	key: :format,
	type: :string,
	description: "Default: \"$date $time [$level] $levelpad$node $metadata $message\"",
	suggestions: ["$metadata[$level] $message"]
	},
	%{
	key: :metadata,
	type: {:list, :atom},
	suggestions: [:request_id]
	}
	]
	},
	%{
	group: :quack,
	type: :group,
	label: "Quack Logger",
	description: "Quack-related settings",
	children: [
	%{
	key: :level,
	type: {:dropdown, :atom},
	description: "Log level",
	suggestions: [:debug, :info, :warn, :error]
	},
	%{
	key: :meta,
	type: {:list, :atom},
	description: "Configure which metadata you want to report on",
	suggestions: [
	:application,
	:module,
	:file,
	:function,
	:line,
	:pid,
	:crash_reason,
	:initial_call,
	:registered_name,
	:all,
	:none
	]
	},
	%{
	key: :webhook_url,
	label: "Webhook URL",
	type: :string,
	description: "Configure the Slack incoming webhook",
	suggestions: ["https://hooks.slack.com/services/YOUR-KEY-HERE"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :frontend_configurations,
	type: :group,
	description:
	"This form can be used to configure a keyword list that keeps the configuration data for any " <>
	"kind of frontend. By default, settings for pleroma_fe and masto_fe are configured. If you want to " <>
	"add your own configuration your settings all fields must be complete.",
	children: [
	%{
	key: :pleroma_fe,
	label: "Pleroma FE",
	type: :map,
	description: "Settings for Pleroma FE",
	suggestions: [
	%{
	alwaysShowSubjectInput: true,
	background: "/static/aurora_borealis.jpg",
	collapseMessageWithSubject: false,
	disableChat: false,
	greentext: false,
	hideFilteredStatuses: false,
	hideMutedPosts: false,
	hidePostStats: false,
	hideSitename: false,
	hideUserStats: false,
	loginMethod: "password",
	logo: "/static/logo.png",
	logoMargin: ".1em",
	logoMask: true,
	minimalScopesMode: false,
	noAttachmentLinks: false,
	nsfwCensorImage: "/static/img/nsfw.74818f9.png",
	postContentType: "text/plain",
	redirectRootLogin: "/main/friends",
	redirectRootNoLogin: "/main/all",
	scopeCopy: true,
	sidebarRight: false,
	showFeaturesPanel: true,
	showInstanceSpecificPanel: false,
	subjectLineBehavior: "email",
	theme: "pleroma-dark",
	webPushNotifications: false
	}
	],
	children: [
	%{
	key: :alwaysShowSubjectInput,
	label: "Always show subject input",
	type: :boolean,
	description: "When disabled, auto-hide the subject field if it's empty"
	},
	%{
	key: :background,
	type: {:string, :image},
	description:
	"URL of the background, unless viewing a user profile with a background that is set",
	suggestions: ["/images/city.jpg"]
	},
	%{
	key: :collapseMessageWithSubject,
	label: "Collapse message with subject",
	type: :boolean,
	description:
	"When a message has a subject (aka Content Warning), collapse it by default"
	},
	%{
	key: :disableChat,
	label: "PleromaFE Chat",
	type: :boolean,
	description: "Disables PleromaFE Chat component"
	},
	%{
	key: :greentext,
	label: "Greentext",
	type: :boolean,
	description: "Enables green text on lines prefixed with the > character"
	},
	%{
	key: :hideFilteredStatuses,
	label: "Hide Filtered Statuses",
	type: :boolean,
	description: "Hides filtered statuses from timelines"
	},
	%{
	key: :hideMutedPosts,
	label: "Hide Muted Posts",
	type: :boolean,
	description: "Hides muted statuses from timelines"
	},
	%{
	key: :hidePostStats,
	label: "Hide post stats",
	type: :boolean,
	description: "Hide notices statistics (repeats, favorites, ...)"
	},
	%{
	key: :hideSitename,
	label: "Hide Sitename",
	type: :boolean,
	description: "Hides instance name from PleromaFE banner"
	},
	%{
	key: :hideUserStats,
	label: "Hide user stats",
	type: :boolean,
	description:
	"Hide profile statistics (posts, posts per day, followers, followings, ...)"
	},
	%{
	key: :logo,
	type: {:string, :image},
	description: "URL of the logo, defaults to Pleroma's logo",
	suggestions: ["/static/logo.png"]
	},
	%{
	key: :logoMargin,
	label: "Logo margin",
	type: :string,
	description:
	"Allows you to adjust vertical margins between logo boundary and navbar borders. " <>
	"The idea is that to have logo's image without any extra margins and instead adjust them to your need in layout.",
	suggestions: [".1em"]
	},
	%{
	key: :logoMask,
	label: "Logo mask",
	type: :boolean,
	description:
	"By default it assumes logo used will be monochrome with alpha channel to be compatible with both light and dark themes. " <>
	"If you want a colorful logo you must disable logoMask."
	},
	%{
	key: :minimalScopesMode,
	label: "Minimal scopes mode",
	type: :boolean,
	description:
	"Limit scope selection to Direct, User default, and Scope of post replying to. " <>
	"Also prevents replying to a DM with a public post from PleromaFE."
	},
	%{
	key: :nsfwCensorImage,
	label: "NSFW Censor Image",
	type: {:string, :image},
	description:
	"URL of the image to use for hiding NSFW media attachments in the timeline",
	suggestions: ["/static/img/nsfw.74818f9.png"]
	},
	%{
	key: :postContentType,
	label: "Post Content Type",
	type: {:dropdown, :atom},
	description: "Default post formatting option",
	suggestions: ["text/plain", "text/html", "text/markdown", "text/bbcode"]
	},
	%{
	key: :redirectRootNoLogin,
	label: "Redirect root no login",
	type: :string,
	description:
	"Relative URL which indicates where to redirect when a user isn't logged in",
	suggestions: ["/main/all"]
	},
	%{
	key: :redirectRootLogin,
	label: "Redirect root login",
	type: :string,
	description:
	"Relative URL which indicates where to redirect when a user is logged in",
	suggestions: ["/main/friends"]
	},
	%{
	key: :scopeCopy,
	label: "Scope copy",
	type: :boolean,
	description: "Copy the scope (private/unlisted/public) in replies to posts by default"
	},
	%{
	key: :sidebarRight,
	label: "Sidebar on Right",
	type: :boolean,
	description: "Change alignment of sidebar and panels to the right"
	},
	%{
	key: :showFeaturesPanel,
	label: "Show instance features panel",
	type: :boolean,
	description:
	"Enables panel displaying functionality of the instance on the About page"
	},
	%{
	key: :showInstanceSpecificPanel,
	label: "Show instance specific panel",
	type: :boolean,
	description: "Whether to show the instance's custom panel"
	},
	%{
	key: :subjectLineBehavior,
	label: "Subject line behavior",
	type: :string,
	description: "Allows changing the default behaviour of subject lines in replies.
	`email`: copy and preprend re:, as in email,
	`masto`: copy verbatim, as in Mastodon,
	`noop`: don't copy the subject.",
	suggestions: ["email", "masto", "noop"]
	},
	%{
	key: :theme,
	type: :string,
	description: "Which theme to use. Available themes are defined in styles.json",
	suggestions: ["pleroma-dark"]
	}
	]
	},
	%{
	key: :masto_fe,
	label: "Masto FE",
	type: :map,
	description: "Settings for Masto FE",
	suggestions: [
	%{
	showInstanceSpecificPanel: true
	}
	],
	children: [
	%{
	key: :showInstanceSpecificPanel,
	label: "Show instance specific panel",
	type: :boolean,
	description: "Whenether to show the instance's specific panel"
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :assets,
	type: :group,
	description:
	"This section configures assets to be used with various frontends. Currently the only option relates to mascots on the mastodon frontend",
	children: [
	%{
	key: :mascots,
	type: {:keyword, :map},
	description:
	"Keyword of mascots, each element must contain both an URL and a mime_type key",
	suggestions: [
	pleroma_fox_tan: %{
	url: "/images/pleroma-fox-tan-smol.png",
	mime_type: "image/png"
	},
	pleroma_fox_tan_shy: %{
	url: "/images/pleroma-fox-tan-shy.png",
	mime_type: "image/png"
	}
	]
	},
	%{
	key: :default_mascot,
	type: :atom,
	description:
	"This will be used as the default mascot on MastoFE. Default: `:pleroma_fox_tan`",
	suggestions: [
	:pleroma_fox_tan
	]
	},
	%{
	key: :default_user_avatar,
	type: {:string, :image},
	description: "URL of the default user avatar",
	suggestions: ["/images/avi.png"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :manifest,
	type: :group,
	description:
	"This section describe PWA manifest instance-specific values. Currently this option relate only for MastoFE.",
	children: [
	%{
	key: :icons,
	type: {:list, :map},
	description: "Describe the icons of the app",
	suggestion: [
	%{
	src: "/static/logo.png"
	},
	%{
	src: "/static/icon.png",
	type: "image/png"
	},
	%{
	src: "/static/icon.ico",
	sizes: "72x72 96x96 128x128 256x256"
	}
	]
	},
	%{
	key: :theme_color,
	type: :string,
	description: "Describe the theme color of the app",
	suggestions: ["#282c37", "mediumpurple"]
	},
	%{
	key: :background_color,
	type: :string,
	description: "Describe the background color of the app",
	suggestions: ["#191b22", "aliceblue"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf,
	tab: :mrf,
	label: "MRF",
	type: :group,
	description: "General MRF settings",
	children: [
	%{
	key: :policies,
	type: [:module, {:list, :module}],
	description:
	"A list of MRF policies enabled. Module names are shortened (removed leading `Pleroma.Web.ActivityPub.MRF.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Web.ActivityPub.MRF}
	},
	%{
	key: :transparency,
	label: "MRF transparency",
	type: :boolean,
	description:
	"Make the content of your Message Rewrite Facility settings public (via nodeinfo)"
	},
	%{
	key: :transparency_exclusions,
	label: "MRF transparency exclusions",
	type: {:list, :string},
	description:
	"Exclude specific instance names from MRF transparency. The use of the exclusions feature will be disclosed in nodeinfo as a boolean value.",
	suggestions: [
	"exclusion.com"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_simple,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.SimplePolicy",
	label: "MRF Simple",
	type: :group,
	description: "Simple ingress policies",
	children: [
	%{
	key: :media_removal,
	type: {:list, :string},
	description: "List of instances to strip media attachments from",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :media_nsfw,
	label: "Media NSFW",
	type: {:list, :string},
	description: "List of instances to tag all media as NSFW (sensitive) from",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :federated_timeline_removal,
	type: {:list, :string},
	description:
	"List of instances to remove from the Federated (aka The Whole Known Network) Timeline",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :reject,
	type: {:list, :string},
	description: "List of instances to reject activities from (except deletes)",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :accept,
	type: {:list, :string},
	description: "List of instances to only accept activities from (except deletes)",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :followers_only,
	type: {:list, :string},
	description: "Force posts from the given instances to be visible by followers only",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :report_removal,
	type: {:list, :string},
	description: "List of instances to reject reports from",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :avatar_removal,
	type: {:list, :string},
	description: "List of instances to strip avatars from",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :banner_removal,
	type: {:list, :string},
	description: "List of instances to strip banners from",
	suggestions: ["example.com", "*.example.com"]
	},
	%{
	key: :reject_deletes,
	type: {:list, :string},
	description: "List of instances to reject deletions from",
	suggestions: ["example.com", "*.example.com"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_activity_expiration,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.ActivityExpirationPolicy",
	label: "MRF Activity Expiration Policy",
	type: :group,
	description: "Adds automatic expiration to all local activities",
	children: [
	%{
	key: :days,
	type: :integer,
	description: "Default global expiration time for all local activities (in days)",
	suggestions: [90, 365]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_subchain,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.SubchainPolicy",
	label: "MRF Subchain",
	type: :group,
	description:
	"This policy processes messages through an alternate pipeline when a given message matches certain criteria." <>
	" All criteria are configured as a map of regular expressions to lists of policy modules.",
	children: [
	%{
	key: :match_actor,
	type: {:map, {:list, :string}},
	description: "Matches a series of regular expressions against the actor field",
	suggestions: [
	%{
	~r/https:\/\/example.com/s => [Pleroma.Web.ActivityPub.MRF.DropPolicy]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_rejectnonpublic,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.RejectNonPublic",
	description: "RejectNonPublic drops posts with non-public visibility settings.",
	label: "MRF Reject Non Public",
	type: :group,
	children: [
	%{
	key: :allow_followersonly,
	label: "Allow followers-only",
	type: :boolean,
	description: "Whether to allow followers-only posts"
	},
	%{
	key: :allow_direct,
	type: :boolean,
	description: "Whether to allow direct messages"
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_hellthread,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.HellthreadPolicy",
	label: "MRF Hellthread",
	type: :group,
	description: "Block messages with excessive user mentions",
	children: [
	%{
	key: :delist_threshold,
	type: :integer,
	description:
	"Number of mentioned users after which the message gets removed from timelines and" <>
	"disables notifications. Set to 0 to disable.",
	suggestions: [10]
	},
	%{
	key: :reject_threshold,
	type: :integer,
	description:
	"Number of mentioned users after which the messaged gets rejected. Set to 0 to disable.",
	suggestions: [20]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_keyword,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.KeywordPolicy",
	label: "MRF Keyword",
	type: :group,
	description: "Reject or Word-Replace messages with a keyword or regex",
	children: [
	%{
	key: :reject,
	type: {:list, :string},
	description:
	"A list of patterns which result in message being rejected. Each pattern can be a string or a regular expression.",
	suggestions: ["foo", ~r/foo/iu]
	},
	%{
	key: :federated_timeline_removal,
	type: {:list, :string},
	description:
	"A list of patterns which result in message being removed from federated timelines (a.k.a unlisted). Each pattern can be a string or a regular expression.",
	suggestions: ["foo", ~r/foo/iu]
	},
	%{
	key: :replace,
	type: {:list, :tuple},
	description:
	"A list of tuples containing {pattern, replacement}. Each pattern can be a string or a regular expression.",
	suggestions: [{"foo", "bar"}, {~r/foo/iu, "bar"}]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_mention,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.MentionPolicy",
	label: "MRF Mention",
	type: :group,
	description: "Block messages which mention a specific user",
	children: [
	%{
	key: :actors,
	type: {:list, :string},
	description: "A list of actors for which any post mentioning them will be dropped",
	suggestions: ["actor1", "actor2"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_vocabulary,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.VocabularyPolicy",
	label: "MRF Vocabulary",
	type: :group,
	description: "Filter messages which belong to certain activity vocabularies",
	children: [
	%{
	key: :accept,
	type: {:list, :string},
	description:
	"A list of ActivityStreams terms to accept. If empty, all supported messages are accepted.",
	suggestions: ["Create", "Follow", "Mention", "Announce", "Like"]
	},
	%{
	key: :reject,
	type: {:list, :string},
	description:
	"A list of ActivityStreams terms to reject. If empty, no messages are rejected.",
	suggestions: ["Create", "Follow", "Mention", "Announce", "Like"]
	}
	]
	},
	# %{
	# group: :pleroma,
	# key: :mrf_user_allowlist,
	# tab: :mrf,
	# related_policy: "Pleroma.Web.ActivityPub.MRF.UserAllowListPolicy",
	# type: :map,
	# description:
	# "The keys in this section are the domain names that the policy should apply to." <>
	# " Each key should be assigned a list of users that should be allowed through by their ActivityPub ID",
	# suggestions: [
	# %{"example.org" => ["https://example.org/users/admin"]}
	# ]
	# ]
	# },
	%{
	group: :pleroma,
	key: :media_proxy,
	type: :group,
	description: "Media proxy",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables proxying of remote media to the instance's proxy"
	},
	%{
	key: :base_url,
	label: "Base URL",
	type: :string,
	description:
	"The base URL to access a user-uploaded file. Useful when you want to proxy the media files via another host/CDN fronts.",
	suggestions: ["https://example.com"]
	},
	%{
	key: :invalidation,
	type: :keyword,
	descpiption: "",
	suggestions: [
	enabled: true,
	provider: Pleroma.Web.MediaProxy.Invalidation.Script
	],
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables media cache object invalidation."
	},
	%{
	key: :provider,
	type: :module,
	description: "Module which will be used to purge objects from the cache.",
	suggestions: [
	Pleroma.Web.MediaProxy.Invalidation.Script,
	Pleroma.Web.MediaProxy.Invalidation.Http
	]
	}
	]
	},
	%{
	key: :proxy_opts,
	label: "Proxy Options",
	type: :keyword,
	description: "Options for Pleroma.ReverseProxy",
	suggestions: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	max_read_duration: 30_000,
	http: [
	follow_redirect: true,
	pool: :media
	]
	],
	children: [
	%{
	key: :redirect_on_failure,
	type: :boolean,
	description:
	"Redirects the client to the real remote URL if there's any HTTP errors. " <>
	"Any error during body processing will not be redirected as the response is chunked."
	},
	%{
	key: :max_body_length,
	type: :integer,
	description:
	"Limits the content length to be approximately the " <>
	"specified length. It is validated with the `content-length` header and also verified when proxying."
	},
	%{
	key: :max_read_duration,
	type: :integer,
	description: "Timeout (in milliseconds) of GET request to remote URI."
	},
	%{
	key: :http,
	label: "HTTP",
	type: :keyword,
	description: "HTTP options",
	children: [
	%{
	key: :adapter,
	type: :keyword,
	description: "Adapter specific options",
	children: [
	%{
	key: :ssl_options,
	type: :keyword,
	label: "SSL Options",
	description: "SSL options for HTTP adapter",
	children: [
	%{
	key: :versions,
	type: {:list, :atom},
	description: "List of TLS version to use",
	suggestions: [:tlsv1, ":tlsv1.1", ":tlsv1.2"]
	}
	]
	}
	]
	},
	%{
	key: :proxy_url,
	label: "Proxy URL",
	type: [:string, :tuple],
	description: "Proxy URL",
	suggestions: ["127.0.0.1:8123", {:socks5, :localhost, 9050}]
	}
	]
	}
	]
	},
	%{
	key: :whitelist,
	type: {:list, :string},
	description: "List of hosts with scheme to bypass the mediaproxy",
	suggestions: ["http://example.com"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :media_preview_proxy,
	type: :group,
	description: "Media preview proxy",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description:
	"Enables proxying of remote media preview to the instance's proxy. Requires enabled media proxy."
	},
	%{
	key: :thumbnail_max_width,
	type: :integer,
	description:
	"Max width of preview thumbnail for images (video preview always has original dimensions)."
	},
	%{
	key: :thumbnail_max_height,
	type: :integer,
	description:
	"Max height of preview thumbnail for images (video preview always has original dimensions)."
	},
	%{
	key: :image_quality,
	type: :integer,
	description: "Quality of the output. Ranges from 0 (min quality) to 100 (max quality)."
	},
	%{
	key: :min_content_length,
	type: :integer,
	description:
	"Min content length to perform preview, in bytes. If greater than 0, media smaller in size will be served as is, without thumbnailing."
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.MediaProxy.Invalidation.Http,
	type: :group,
	description: "HTTP invalidate settings",
	children: [
	%{
	key: :method,
	type: :atom,
	description: "HTTP method of request. Default: :purge"
	},
	%{
	key: :headers,
	type: {:keyword, :string},
	description: "HTTP headers of request",
	suggestions: [{"x-refresh", 1}]
	},
	%{
	key: :options,
	type: :keyword,
	description: "Request options",
	children: [
	%{
	key: :params,
	type: {:map, :string}
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.MediaProxy.Invalidation.Script,
	type: :group,
	description: "Script invalidate settings",
	children: [
	%{
	key: :script_path,
	type: :string,
	description: "Path to shell script. Which will run purge cache.",
	suggestions: ["./installation/nginx-cache-purge.sh.example"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :gopher,
	type: :group,
	description: "Gopher settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables the gopher interface"
	},
	%{
	key: :ip,
	label: "IP",
	type: :tuple,
	description: "IP address to bind to",
	suggestions: [{0, 0, 0, 0}]
	},
	%{
	key: :port,
	type: :integer,
	description: "Port to bind to",
	suggestions: [9999]
	},
	%{
	key: :dstport,
	type: :integer,
	description: "Port advertised in URLs (optional, defaults to port)",
	suggestions: [9999]
	}
	]
	},
	%{
	group: :pleroma,
	key: :activitypub,
	label: "ActivityPub",
	type: :group,
	description: "ActivityPub-related settings",
	children: [
	%{
	key: :unfollow_blocked,
	type: :boolean,
	description: "Whether blocks result in people getting unfollowed"
	},
	%{
	key: :outgoing_blocks,
	type: :boolean,
	description: "Whether to federate blocks to other instances"
	},
	%{
	key: :sign_object_fetches,
	type: :boolean,
	description: "Sign object fetches with HTTP signatures"
	},
	%{
	key: :note_replies_output_limit,
	type: :integer,
	description:
	"The number of Note replies' URIs to be included with outgoing federation (`5` to match Mastodon hardcoded value, `0` to disable the output)"
	},
	%{
	key: :follow_handshake_timeout,
	type: :integer,
	description: "Following handshake timeout",
	suggestions: [500]
	}
	]
	},
	%{
	group: :pleroma,
	key: :http_security,
	label: "HTTP security",
	type: :group,
	description: "HTTP security settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether the managed content security policy is enabled"
	},
	%{
	key: :sts,
	label: "STS",
	type: :boolean,
	description: "Whether to additionally send a Strict-Transport-Security header"
	},
	%{
	key: :sts_max_age,
	label: "STS max age",
	type: :integer,
	description: "The maximum age for the Strict-Transport-Security header if sent",
	suggestions: [31_536_000]
	},
	%{
	key: :ct_max_age,
	label: "CT max age",
	type: :integer,
	description: "The maximum age for the Expect-CT header if sent",
	suggestions: [2_592_000]
	},
	%{
	key: :referrer_policy,
	type: :string,
	description: "The referrer policy to use, either \"same-origin\" or \"no-referrer\"",
	suggestions: ["same-origin", "no-referrer"]
	},
	%{
	key: :report_uri,
	label: "Report URI",
	type: :string,
	description: "Adds the specified URL to report-uri and report-to group in CSP header",
	suggestions: ["https://example.com/report-uri"]
	}
	]
	},
	%{
	group: :web_push_encryption,
	key: :vapid_details,
	label: "Vapid Details",
	type: :group,
	description:
	"Web Push Notifications configuration. You can use the mix task mix web_push.gen.keypair to generate it.",
	children: [
	%{
	key: :subject,
	type: :string,
	description:
	"A mailto link for the administrative contact." <>
	" It's best if this email is not a personal email address, but rather a group email to the instance moderation team.",
	suggestions: ["mailto:moderators@pleroma.com"]
	},
	%{
	key: :public_key,
	type: :string,
	description: "VAPID public key",
	suggestions: ["Public key"]
	},
	%{
	key: :private_key,
	type: :string,
	description: "VAPID private key",
	suggestions: ["Private key"]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Captcha,
	type: :group,
	description: "Captcha-related settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether the captcha should be shown on registration"
	},
	%{
	key: :method,
	type: :module,
	description: "The method/service to use for captcha",
	suggestions: [Pleroma.Captcha.Kocaptcha, Pleroma.Captcha.Native]
	},
	%{
	key: :seconds_valid,
	type: :integer,
	description: "The time in seconds for which the captcha is valid",
	suggestions: [60]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Captcha.Kocaptcha,
	type: :group,
	description:
	"Kocaptcha is a very simple captcha service with a single API endpoint, the source code is" <>
	" here: https://github.com/koto-bank/kocaptcha. The default endpoint (https://captcha.kotobank.ch) is hosted by the developer.",
	children: [
	%{
	key: :endpoint,
	type: :string,
	description: "The kocaptcha endpoint to use",
	suggestions: ["https://captcha.kotobank.ch"]
	}
	]
	},
	%{
	group: :pleroma,
	label: "Pleroma Admin Token",
	type: :group,
	description:
	"Allows setting a token that can be used to authenticate requests with admin privileges without a normal user account token. Append the `admin_token` parameter to requests to utilize it. (Please reconsider using HTTP Basic Auth or OAuth-based authentication if possible)",
	children: [
	%{
	key: :admin_token,
	type: :string,
	description: "Admin token",
	suggestions: [
	"Please use a high entropy string or UUID"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Oban,
	type: :group,
	description: """
	[Oban](https://github.com/sorentwo/oban) asynchronous job processor configuration.

	Note: if you are running PostgreSQL in [`silent_mode`](https://postgresqlco.nf/en/doc/param/silent_mode?version=9.1),
	it's advised to set [`log_destination`](https://postgresqlco.nf/en/doc/param/log_destination?version=9.1) to `syslog`,
	otherwise `postmaster.log` file may grow because of "you don't own a lock of type ShareLock" warnings
	(see https://github.com/sorentwo/oban/issues/52).
	""",
	children: [
	%{
	key: :log,
	type: {:dropdown, :atom},
	description: "Logs verbose mode",
	suggestions: [false, :error, :warn, :info, :debug]
	},
	%{
	key: :queues,
	type: {:keyword, :integer},
	description:
	"Background jobs queues (keys: queues, values: max numbers of concurrent jobs)",
	suggestions: [
	activity_expiration: 10,
	attachments_cleanup: 5,
	background: 5,
	federator_incoming: 50,
	federator_outgoing: 50,
	mailer: 10,
	scheduled_activities: 10,
	transmogrifier: 20,
	web_push: 50
	],
	children: [
	%{
	key: :activity_expiration,
	type: :integer,
	description: "Activity expiration queue",
	suggestions: [10]
	},
	%{
	key: :attachments_cleanup,
	type: :integer,
	description: "Attachment deletion queue",
	suggestions: [5]
	},
	%{
	key: :background,
	type: :integer,
	description: "Background queue",
	suggestions: [5]
	},
	%{
	key: :federator_incoming,
	type: :integer,
	description: "Incoming federation queue",
	suggestions: [50]
	},
	%{
	key: :federator_outgoing,
	type: :integer,
	description: "Outgoing federation queue",
	suggestions: [50]
	},
	%{
	key: :mailer,
	type: :integer,
	description: "Email sender queue, see Pleroma.Emails.Mailer",
	suggestions: [10]
	},
	%{
	key: :scheduled_activities,
	type: :integer,
	description: "Scheduled activities queue, see Pleroma.ScheduledActivities",
	suggestions: [10]
	},
	%{
	key: :transmogrifier,
	type: :integer,
	description: "Transmogrifier queue",
	suggestions: [20]
	},
	%{
	key: :web_push,
	type: :integer,
	description: "Web push notifications queue",
	suggestions: [50]
	}
	]
	},
	%{
	key: :crontab,
	type: {:list, :tuple},
	description: "Settings for cron background jobs",
	suggestions: [
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :workers,
	type: :group,
	description: "Includes custom worker options not interpretable directly by `Oban`",
	children: [
	%{
	key: :retries,
	type: {:keyword, :integer},
	description: "Max retry attempts for failed jobs, per `Oban` queue",
	suggestions: [
	federator_incoming: 5,
	federator_outgoing: 5
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.Metadata,
	type: :group,
	description: "Metadata-related settings",
	children: [
	%{
	key: :providers,
	type: {:list, :module},
	description: "List of metadata providers to enable",
	suggestions: [
	Pleroma.Web.Metadata.Providers.OpenGraph,
	Pleroma.Web.Metadata.Providers.TwitterCard,
	Pleroma.Web.Metadata.Providers.RelMe,
	Pleroma.Web.Metadata.Providers.Feed
	]
	},
	%{
	key: :unfurl_nsfw,
	label: "Unfurl NSFW",
	type: :boolean,
	description: "When enabled NSFW attachments will be shown in previews"
	}
	]
	},
	%{
	group: :pleroma,
	key: :rich_media,
	type: :group,
	description:
	"If enabled the instance will parse metadata from attached links to generate link previews",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables RichMedia parsing of URLs"
	},
	%{
	key: :ignore_hosts,
	type: {:list, :string},
	description: "List of hosts which will be ignored by the metadata parser",
	suggestions: ["accounts.google.com", "xss.website"]
	},
	%{
	key: :ignore_tld,
	label: "Ignore TLD",
	type: {:list, :string},
	description: "List TLDs (top-level domains) which will ignore for parse metadata",
	suggestions: ["local", "localdomain", "lan"]
	},
	%{
	key: :parsers,
	type: {:list, :module},
	description:
	"List of Rich Media parsers. Module names are shortened (removed leading `Pleroma.Web.RichMedia.Parsers.` part), but on adding custom module you need to use full name.",
	suggestions: [
	Pleroma.Web.RichMedia.Parsers.OEmbed,
	Pleroma.Web.RichMedia.Parsers.TwitterCard
	]
	},
	%{
	key: :ttl_setters,
	label: "TTL setters",
	type: {:list, :module},
	description:
	"List of rich media TTL setters. Module names are shortened (removed leading `Pleroma.Web.RichMedia.Parser.` part), but on adding custom module you need to use full name.",
	suggestions: [
	Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl
	]
	},
	%{
	key: :failure_backoff,
	type: :integer,
	description:
	"Amount of milliseconds after request failure, during which the request will not be retried.",
	suggestions: [60_000]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Formatter,
	label: "Linkify",
	type: :group,
	description:
	"Configuration for Pleroma's link formatter which parses mentions, hashtags, and URLs.",
	children: [
	%{
	key: :class,
	type: [:string, :boolean],
	description: "Specify the class to be added to the generated link. Disable to clear.",
	suggestions: ["auto-linker", false]
	},
	%{
	key: :rel,
	type: [:string, :boolean],
	description: "Override the rel attribute. Disable to clear.",
	suggestions: ["ugc", "noopener noreferrer", false]
	},
	%{
	key: :new_window,
	type: :boolean,
	description: "Link URLs will open in a new window/tab."
	},
	%{
	key: :truncate,
	type: [:integer, :boolean],
	description:
	"Set to a number to truncate URLs longer than the number. Truncated URLs will end in `...`",
	suggestions: [15, false]
	},
	%{
	key: :strip_prefix,
	type: :boolean,
	description: "Strip the scheme prefix."
	},
	%{
	key: :extra,
	type: :boolean,
	description: "Link URLs with rarely used schemes (magnet, ipfs, irc, etc.)"
	},
	%{
	key: :validate_tld,
	type: [:atom, :boolean],
	description:
	"Set to false to disable TLD validation for URLs/emails. Can be set to :no_scheme to validate TLDs only for URLs without a scheme (e.g `example.com` will be validated, but `http://example.loki` won't)",
	suggestions: [:no_scheme, true]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.ScheduledActivity,
	type: :group,
	description: "Scheduled activities settings",
	children: [
	%{
	key: :daily_user_limit,
	type: :integer,
	description:
	"The number of scheduled activities a user is allowed to create in a single day. Default: 25.",
	suggestions: [25]
	},
	%{
	key: :total_user_limit,
	type: :integer,
	description:
	"The number of scheduled activities a user is allowed to create in total. Default: 300.",
	suggestions: [300]
	},
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether scheduled activities are sent to the job queue to be executed"
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Workers.PurgeExpiredActivity,
	type: :group,
	description: "Expired activities settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables expired activities addition & deletion"
	},
	%{
	key: :min_lifetime,
	type: :integer,
	description: "Minimum lifetime for ephemeral activity (in seconds)",
	suggestions: [600]
	}
	]
	},
	%{
	group: :pleroma,
	label: "Pleroma Authenticator",
	type: :group,
	description: "Authenticator",
	children: [
	%{
	key: Pleroma.Web.Auth.Authenticator,
	type: :module,
	suggestions: [Pleroma.Web.Auth.PleromaAuthenticator, Pleroma.Web.Auth.LDAPAuthenticator]
	}
	]
	},
	%{
	group: :pleroma,
	key: :ldap,
	label: "LDAP",
	type: :group,
	description:
	"Use LDAP for user authentication. When a user logs in to the Pleroma instance, the name and password" <>
	" will be verified by trying to authenticate (bind) to a LDAP server." <>
	" If a user exists in the LDAP directory but there is no account with the same name yet on the" <>
	" Pleroma instance then a new Pleroma account will be created with the same name as the LDAP user name.",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables LDAP authentication"
	},
	%{
	key: :host,
	type: :string,
	description: "LDAP server hostname",
	suggestions: ["localhosts"]
	},
	%{
	key: :port,
	type: :integer,
	description: "LDAP port, e.g. 389 or 636",
	suggestions: [389, 636]
	},
	%{
	key: :ssl,
	label: "SSL",
	type: :boolean,
	description: "Enable to use SSL, usually implies the port 636"
	},
	%{
	key: :sslopts,
	label: "SSL options",
	type: :keyword,
	description: "Additional SSL options",
	suggestions: [cacertfile: "path/to/file/with/PEM/cacerts", verify: :verify_peer],
	children: [
	%{
	key: :cacertfile,
	type: :string,
	description: "Path to file with PEM encoded cacerts",
	suggestions: ["path/to/file/with/PEM/cacerts"]
	},
	%{
	key: :verify,
	type: :atom,
	description: "Type of cert verification",
	suggestions: [:verify_peer]
	}
	]
	},
	%{
	key: :tls,
	label: "TLS",
	type: :boolean,
	description: "Enable to use STARTTLS, usually implies the port 389"
	},
	%{
	key: :tlsopts,
	label: "TLS options",
	type: :keyword,
	description: "Additional TLS options",
	suggestions: [cacertfile: "path/to/file/with/PEM/cacerts", verify: :verify_peer],
	children: [
	%{
	key: :cacertfile,
	type: :string,
	description: "Path to file with PEM encoded cacerts",
	suggestions: ["path/to/file/with/PEM/cacerts"]
	},
	%{
	key: :verify,
	type: :atom,
	description: "Type of cert verification",
	suggestions: [:verify_peer]
	}
	]
	},
	%{
	key: :base,
	type: :string,
	description: "LDAP base, e.g. \"dc=example,dc=com\"",
	suggestions: ["dc=example,dc=com"]
	},
	%{
	key: :uid,
	label: "UID",
	type: :string,
	description:
	"LDAP attribute name to authenticate the user, e.g. when \"cn\", the filter will be \"cn=username,base\"",
	suggestions: ["cn"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :auth,
	type: :group,
	description: "Authentication / authorization settings",
	children: [
	%{
	key: :enforce_oauth_admin_scope_usage,
	label: "Enforce OAuth admin scope usage",
	type: :boolean,
	description:
	"OAuth admin scope requirement toggle. " <>
	"If enabled, admin actions explicitly demand admin OAuth scope(s) presence in OAuth token " <>
	"(client app must support admin scopes). If disabled and token doesn't have admin scope(s), " <>
	"`is_admin` user flag grants access to admin-specific actions."
	},
	%{
	key: :auth_template,
	type: :string,
	description:
	"Authentication form template. By default it's `show.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/show.html.ee`.",
	suggestions: ["show.html"]
	},
	%{
	key: :oauth_consumer_template,
	label: "OAuth consumer template",
	type: :string,
	description:
	"OAuth consumer mode authentication form template. By default it's `consumer.html` which corresponds to" <>
	" `lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex`.",
	suggestions: ["consumer.html"]
	},
	%{
	key: :oauth_consumer_strategies,
	label: "OAuth consumer strategies",
	type: {:list, :string},
	description:
	"The list of enabled OAuth consumer strategies. By default it's set by OAUTH_CONSUMER_STRATEGIES environment variable." <>
	" Each entry in this space-delimited string should be of format \"strategy\" or \"strategy:dependency\"" <>
	" (e.g. twitter or keycloak:ueberauth_keycloak_strategy in case dependency is named differently than ueberauth_<strategy>).",
	suggestions: ["twitter", "keycloak:ueberauth_keycloak_strategy"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :email_notifications,
	type: :group,
	description: "Email notifications settings",
	children: [
	%{
	key: :digest,
	type: :map,
	description:
	"emails of \"what you've missed\" for users who have been inactive for a while",
	suggestions: [
	%{
	active: false,
	schedule: "0 0 * * 0",
	interval: 7,
	inactivity_threshold: 7
	}
	],
	children: [
	%{
	key: :active,
	label: "Enabled",
	type: :boolean,
	description: "Globally enable or disable digest emails"
	},
	%{
	key: :schedule,
	type: :string,
	description:
	"When to send digest email, in crontab format. \"0 0 0\" is the default, meaning \"once a week at midnight on Sunday morning\".",
	suggestions: ["0 0 * * 0"]
	},
	%{
	key: :interval,
	type: :integer,
	description: "Minimum interval between digest emails to one user",
	suggestions: [7]
	},
	%{
	key: :inactivity_threshold,
	type: :integer,
	description: "Minimum user inactivity threshold",
	suggestions: [7]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.UserEmail,
	type: :group,
	description: "Email template settings",
	children: [
	%{
	key: :logo,
	type: {:string, :image},
	description: "A path to a custom logo. Set it to `nil` to use the default Pleroma logo.",
	suggestions: ["some/path/logo.png"]
	},
	%{
	key: :styling,
	type: :map,
	description: "A map with color settings for email templates.",
	suggestions: [
	%{
	link_color: "#d8a070",
	background_color: "#2C3645",
	content_background_color: "#1B2635",
	header_color: "#d8a070",
	text_color: "#b9b9ba",
	text_muted_color: "#b9b9ba"
	}
	],
	children: [
	%{
	key: :link_color,
	type: :string,
	suggestions: ["#d8a070"]
	},
	%{
	key: :background_color,
	type: :string,
	suggestions: ["#2C3645"]
	},
	%{
	key: :content_background_color,
	type: :string,
	suggestions: ["#1B2635"]
	},
	%{
	key: :header_color,
	type: :string,
	suggestions: ["#d8a070"]
	},
	%{
	key: :text_color,
	type: :string,
	suggestions: ["#b9b9ba"]
	},
	%{
	key: :text_muted_color,
	type: :string,
	suggestions: ["#b9b9ba"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.NewUsersDigestEmail,
	type: :group,
	description: "New users admin email digest",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables new users admin digest email when `true`"
	}
	]
	},
	%{
	group: :pleroma,
	key: :oauth2,
	label: "OAuth2",
	type: :group,
	description: "Configure OAuth 2 provider capabilities",
	children: [
	%{
	key: :token_expires_in,
	type: :integer,
	description: "The lifetime in seconds of the access token",
	suggestions: [600]
	},
	%{
	key: :issue_new_refresh_token,
	type: :boolean,
	description:
	"Keeps old refresh token or generate new refresh token when to obtain an access token"
	},
	%{
	key: :clean_expired_tokens,
	type: :boolean,
	description: "Enable a background job to clean expired OAuth tokens. Default: disabled."
	}
	]
	},
	%{
	group: :pleroma,
	key: :emoji,
	type: :group,
	children: [
	%{
	key: :shortcode_globs,
	type: {:list, :string},
	description: "Location of custom emoji files. * can be used as a wildcard.",
	suggestions: ["/emoji/custom/*/.png"]
	},
	%{
	key: :pack_extensions,
	type: {:list, :string},
	description:
	"A list of file extensions for emojis, when no emoji.txt for a pack is present",
	suggestions: [".png", ".gif"]
	},
	%{
	key: :groups,
	type: {:keyword, {:list, :string}},
	description:
	"Emojis are ordered in groups (tags). This is an array of key-value pairs where the key is the group name" <>
	" and the value is the location or array of locations. * can be used as a wildcard.",
	suggestions: [
	Custom: ["/emoji/.png", "/emoji//.png"]
	]
	},
	%{
	key: :default_manifest,
	type: :string,
	description:
	"Location of the JSON-manifest. This manifest contains information about the emoji-packs you can download." <>
	" Currently only one manifest can be added (no arrays).",
	suggestions: ["https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"]
	},
	%{
	key: :shared_pack_cache_seconds_per_file,
	label: "Shared pack cache s/file",
	type: :integer,
	descpiption:
	"When an emoji pack is shared, the archive is created and cached in memory" <>
	" for this amount of seconds multiplied by the number of files.",
	suggestions: [60]
	}
	]
	},
	%{
	group: :pleroma,
	key: :rate_limit,
	type: :group,
	description:
	"Rate limit settings. This is an advanced feature enabled only for :authentication by default.",
	children: [
	%{
	key: :search,
	type: [:tuple, {:list, :tuple}],
	description: "For the search requests (account & status search etc.)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :timeline,
	type: [:tuple, {:list, :tuple}],
	description: "For requests to timelines (each timeline has it's own limiter)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :app_account_creation,
	type: [:tuple, {:list, :tuple}],
	description: "For registering user accounts from the same IP address",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :relations_actions,
	type: [:tuple, {:list, :tuple}],
	description: "For actions on relationships with all users (follow, unfollow)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :relation_id_action,
	label: "Relation ID action",
	type: [:tuple, {:list, :tuple}],
	description: "For actions on relation with a specific user (follow, unfollow)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :statuses_actions,
	type: [:tuple, {:list, :tuple}],
	description:
	"For create / delete / fav / unfav / reblog / unreblog actions on any statuses",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :status_id_action,
	label: "Status ID action",
	type: [:tuple, {:list, :tuple}],
	description:
	"For fav / unfav or reblog / unreblog actions on the same status by the same user",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :authentication,
	type: [:tuple, {:list, :tuple}],
	description: "For authentication create / password check / user existence check requests",
	suggestions: [{60_000, 15}]
	}
	]
	},
	%{
	group: :esshd,
	label: "ESSHD",
	type: :group,
	description:
	"Before enabling this you must add :esshd to mix.exs as one of the extra_applications " <>
	"and generate host keys in your priv dir with ssh-keygen -m PEM -N \"\" -b 2048 -t rsa -f ssh_host_rsa_key",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables SSH"
	},
	%{
	key: :priv_dir,
	type: :string,
	description: "Dir with SSH keys",
	suggestions: ["/some/path/ssh_keys"]
	},
	%{
	key: :handler,
	type: :string,
	description: "Handler module",
	suggestions: ["Pleroma.BBS.Handler"]
	},
	%{
	key: :port,
	type: :integer,
	description: "Port to connect",
	suggestions: [10_022]
	},
	%{
	key: :password_authenticator,
	type: :string,
	description: "Authenticator module",
	suggestions: ["Pleroma.BBS.Authenticator"]
	}
	]
	},
	%{
	group: :mime,
	label: "Mime Types",
	type: :group,
	description: "Mime Types settings",
	children: [
	%{
	key: :types,
	type: :map,
	suggestions: [
	%{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"application/jrd+json" => ["jrd+json"],
	"application/activity+json" => ["activity+json"],
	"application/ld+json" => ["activity+json"]
	}
	],
	children: [
	%{
	key: "application/xml",
	type: {:list, :string},
	suggestions: ["xml"]
	},
	%{
	key: "application/xrd+xml",
	type: {:list, :string},
	suggestions: ["xrd+xml"]
	},
	%{
	key: "application/jrd+json",
	type: {:list, :string},
	suggestions: ["jrd+json"]
	},
	%{
	key: "application/activity+json",
	type: {:list, :string},
	suggestions: ["activity+json"]
	},
	%{
	key: "application/ld+json",
	type: {:list, :string},
	suggestions: ["activity+json"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :chat,
	type: :group,
	description: "Pleroma chat settings",
	children: [
	%{
	key: :enabled,
	type: :boolean
	}
	]
	},
	%{
	group: :pleroma,
	key: :http,
	label: "HTTP",
	type: :group,
	description: "HTTP settings",
	children: [
	%{
	key: :proxy_url,
	label: "Proxy URL",
	type: [:string, :tuple],
	description: "Proxy URL",
	suggestions: ["localhost:9020", {:socks5, :localhost, 3090}]
	},
	%{
	key: :send_user_agent,
	type: :boolean
	},
	%{
	key: :user_agent,
	type: [:string, :atom],
	description:
	"What user agent to use. Must be a string or an atom `:default`. Default value is `:default`.",
	suggestions: ["Pleroma", :default]
	},
	%{
	key: :adapter,
	type: :keyword,
	description: "Adapter specific options",
	suggestions: [],
	children: [
	%{
	key: :ssl_options,
	type: :keyword,
	label: "SSL Options",
	description: "SSL options for HTTP adapter",
	children: [
	%{
	key: :versions,
	type: {:list, :atom},
	description: "List of TLS version to use",
	suggestions: [:tlsv1, ":tlsv1.1", ":tlsv1.2"]
	}
	]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :markup,
	label: "Markup Settings",
	type: :group,
	children: [
	%{
	key: :allow_inline_images,
	type: :boolean
	},
	%{
	key: :allow_headings,
	type: :boolean
	},
	%{
	key: :allow_tables,
	type: :boolean
	},
	%{
	key: :allow_fonts,
	type: :boolean
	},
	%{
	key: :scrub_policy,
	type: {:list, :module},
	description:
	"Module names are shortened (removed leading `Pleroma.HTML.` part), but on adding custom module you need to use full name.",
	suggestions: [Pleroma.HTML.Transform.MediaProxy, Pleroma.HTML.Scrubber.Default]
	}
	]
	},
	%{
	group: :pleroma,
	key: :user,
	type: :group,
	children: [
	%{
	key: :deny_follow_blocked,
	type: :boolean
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_normalize_markup,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.NormalizeMarkup",
	label: "MRF Normalize Markup",
	description: "MRF NormalizeMarkup settings. Scrub configured hypertext markup.",
	type: :group,
	children: [
	%{
	key: :scrub_policy,
	type: :module,
	suggestions: [Pleroma.HTML.Scrubber.Default]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.User,
	type: :group,
	children: [
	%{
	key: :restricted_nicknames,
	type: {:list, :string},
	description: "List of nicknames users may not register with.",
	suggestions: [
	".well-known",
	"~",
	"about",
	"activities",
	"api",
	"auth",
	"check_password",
	"dev",
	"friend-requests",
	"inbox",
	"internal",
	"main",
	"media",
	"nodeinfo",
	"notice",
	"oauth",
	"objects",
	"ostatus_subscribe",
	"pleroma",
	"proxy",
	"push",
	"registration",
	"relay",
	"settings",
	"status",
	"tag",
	"user-search",
	"user_exists",
	"users",
	"web"
	]
	},
	%{
	key: :email_blacklist,
	type: {:list, :string},
	description: "List of email domains users may not register with.",
	suggestions: ["mailinator.com", "maildrop.cc"]
	}
	]
	},
	%{
	group: :cors_plug,
	label: "CORS plug config",
	type: :group,
	children: [
	%{
	key: :max_age,
	type: :integer,
	suggestions: [86_400]
	},
	%{
	key: :methods,
	type: {:list, :string},
	suggestions: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"]
	},
	%{
	key: :expose,
	type: {:list, :string},
	suggestions: [
	"Link",
	"X-RateLimit-Reset",
	"X-RateLimit-Limit",
	"X-RateLimit-Remaining",
	"X-Request-Id",
	"Idempotency-Key"
	]
	},
	%{
	key: :credentials,
	type: :boolean
	},
	%{
	key: :headers,
	type: {:list, :string},
	suggestions: ["Authorization", "Content-Type", "Idempotency-Key"]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Plugs.RemoteIp,
	type: :group,
	description: """
	`Pleroma.Plugs.RemoteIp` is a shim to call [`RemoteIp`](https://git.pleroma.social/pleroma/remote_ip) but with runtime configuration.
	If your instance is not behind at least one reverse proxy, you should not enable this plug.
	""",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enable/disable the plug. Default: disabled."
	},
	%{
	key: :headers,
	type: {:list, :string},
	description:
	"A list of strings naming the `req_headers` to use when deriving the `remote_ip`. Order does not matter. Default: `~w[forwarded x-forwarded-for x-client-ip x-real-ip]`."
	},
	%{
	key: :proxies,
	type: {:list, :string},
	description:
	"A list of strings in [CIDR](https://en.wikipedia.org/wiki/CIDR) notation specifying the IPs of known proxies. Default: `[]`."
	},
	%{
	key: :reserved,
	type: {:list, :string},
	description:
	"Defaults to [localhost](https://en.wikipedia.org/wiki/Localhost) and [private network](https://en.wikipedia.org/wiki/Private_network)."
	}
	]
	},
	%{
	group: :pleroma,
	key: :web_cache_ttl,
	label: "Web cache TTL",
	type: :group,
	description:
	"The expiration time for the web responses cache. Values should be in milliseconds or `nil` to disable expiration.",
	children: [
	%{
	key: :activity_pub,
	type: :integer,
	description:
	"Activity pub routes (except question activities). Default: `nil` (no expiration).",
	suggestions: [30_000, nil]
	},
	%{
	key: :activity_pub_question,
	type: :integer,
	description: "Activity pub routes (question activities). Default: `30_000` (30 seconds).",
	suggestions: [30_000]
	}
	]
	},
	%{
	group: :pleroma,
	key: :static_fe,
	label: "Static FE",
	type: :group,
	description:
	"Render profiles and posts using server-generated HTML that is viewable without using JavaScript",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables the rendering of static HTML. Default: disabled."
	}
	]
	},
	%{
	group: :pleroma,
	key: :feed,
	type: :group,
	description: "Configure feed rendering",
	children: [
	%{
	key: :post_title,
	type: :map,
	description: "Configure title rendering",
	children: [
	%{
	key: :max_length,
	type: :integer,
	description: "Maximum number of characters before truncating title",
	suggestions: [100]
	},
	%{
	key: :omission,
	type: :string,
	description: "Replacement which will be used after truncating string",
	suggestions: ["..."]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_object_age,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy",
	label: "MRF Object Age",
	type: :group,
	description:
	"Rejects or delists posts based on their timestamp deviance from your server's clock.",
	children: [
	%{
	key: :threshold,
	type: :integer,
	description: "Required age (in seconds) of a post before actions are taken.",
	suggestions: [172_800]
	},
	%{
	key: :actions,
	type: {:list, :atom},
	description:
	"A list of actions to apply to the post. `:delist` removes the post from public timelines; " <>
	"`:strip_followers` removes followers from the ActivityPub recipient list ensuring they won't be delivered to home timelines; " <>
	"`:reject` rejects the message entirely",
	suggestions: [:delist, :strip_followers, :reject]
	}
	]
	},
	%{
	group: :pleroma,
	key: :modules,
	type: :group,
	description: "Custom Runtime Modules",
	children: [
	%{
	key: :runtime_dir,
	type: :string,
	description: "A path to custom Elixir modules (such as MRF policies)."
	}
	]
	},
	%{
	group: :pleroma,
	key: :streamer,
	type: :group,
	description: "Settings for notifications streamer",
	children: [
	%{
	key: :workers,
	type: :integer,
	description: "Number of workers to send notifications",
	suggestions: [3]
	},
	%{
	key: :overflow_workers,
	type: :integer,
	description: "Maximum number of workers created if pool is empty",
	suggestions: [2]
	}
	]
	},
	%{
	group: :pleroma,
	key: :connections_pool,
	type: :group,
	description: "Advanced settings for `Gun` connections pool",
	children: [
	%{
	key: :connection_acquisition_wait,
	type: :integer,
	description:
	"Timeout to acquire a connection from pool. The total max time is this value multiplied by the number of retries. Default: 250ms.",
	suggestions: [250]
	},
	%{
	key: :connection_acquisition_retries,
	type: :integer,
	description:
	"Number of attempts to acquire the connection from the pool if it is overloaded. Default: 5",
	suggestions: [5]
	},
	%{
	key: :max_connections,
	type: :integer,
	description: "Maximum number of connections in the pool. Default: 250 connections.",
	suggestions: [250]
	},
	%{
	key: :connect_timeout,
	type: :integer,
	description: "Timeout while `gun` will wait until connection is up. Default: 5000ms.",
	suggestions: [5000]
	},
	%{
	key: :reclaim_multiplier,
	type: :integer,
	description:
	"Multiplier for the number of idle connection to be reclaimed if the pool is full. For example if the pool maxes out at 250 connections and this setting is set to 0.3, the pool will reclaim at most 75 idle connections if it's overloaded. Default: 0.1",
	suggestions: [0.1]
	}
	]
	},
	%{
	group: :pleroma,
	key: :pools,
	type: :group,
	description: "Advanced settings for `Gun` workers pools",
	children:
	Enum.map([:federation, :media, :upload, :default], fn pool_name ->
	%{
	key: pool_name,
	type: :keyword,
	description: "Settings for #{pool_name} pool.",
	children: [
	%{
	key: :size,
	type: :integer,
	description: "Maximum number of concurrent requests in the pool.",
	suggestions: [50]
	},
	%{
	key: :max_waiting,
	type: :integer,
	description:
	"Maximum number of requests waiting for other requests to finish. After this number is reached, the pool will start returning errrors when a new request is made",
	suggestions: [10]
	},
	%{
	key: :recv_timeout,
	type: :integer,
	description: "Timeout for the pool while gun will wait for response",
	suggestions: [10_000]
	}
	]
	}
	end)
	},
	%{
	group: :pleroma,
	key: :hackney_pools,
	type: :group,
	description: "Advanced settings for `Hackney` connections pools",
	children: [
	%{
	key: :federation,
	type: :keyword,
	description: "Settings for federation pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [50]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [150_000]
	}
	]
	},
	%{
	key: :media,
	type: :keyword,
	description: "Settings for media pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [50]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [150_000]
	}
	]
	},
	%{
	key: :upload,
	type: :keyword,
	description: "Settings for upload pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [25]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [300_000]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :restrict_unauthenticated,
	label: "Restrict Unauthenticated",
	type: :group,
	description:
	"Disallow viewing timelines, user profiles and statuses for unauthenticated users.",
	children: [
	%{
	key: :timelines,
	type: :map,
	description: "Settings for public and federated timelines.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view public timeline."
	},
	%{
	key: :federated,
	type: :boolean,
	description: "Disallow view federated timeline."
	}
	]
	},
	%{
	key: :profiles,
	type: :map,
	description: "Settings for user profiles.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view local user profiles."
	},
	%{
	key: :remote,
	type: :boolean,
	description: "Disallow view remote user profiles."
	}
	]
	},
	%{
	key: :activities,
	type: :map,
	description: "Settings for statuses.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view local statuses."
	},
	%{
	key: :remote,
	type: :boolean,
	description: "Disallow view remote statuses."
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.ApiSpec.CastAndValidate,
	type: :group,
	children: [
	%{
	key: :strict,
	type: :boolean,
	description:
	"Enables strict input validation (useful in development, not recommended in production)"
	}
	]
	},
	%{
	group: :pleroma,
	key: :instances_favicons,
	type: :group,
	description: "Control favicons for instances",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Allow/disallow displaying and getting instances favicons"
	}
	]
	},
	%{
	group: :ex_aws,
	key: :s3,
	type: :group,
	descriptions: "S3 service related settings",
	children: [
	%{
	key: :access_key_id,
	type: :string,
	description: "S3 access key ID",
	suggestions: ["AKIAQ8UKHTGIYN7DMWWJ"]
	},
	%{
	key: :secret_access_key,
	type: :string,
	description: "Secret access key",
	suggestions: ["JFGt+fgH1UQ7vLUQjpW+WvjTdV/UNzVxcwn7DkaeFKtBS5LvoXvIiME4NQBsT6ZZ"]
	},
	%{
	key: :host,
	type: :string,
	description: "S3 host",
	suggestions: ["s3.eu-central-1.amazonaws.com"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :frontends,
	type: :group,
	description: "Installed frontends management",
	children: [
	%{
	key: :primary,
	type: :map,
	description: "Primary frontend, the one that is served for all pages by default",
	children: installed_frontend_options
	},
	%{
	key: :admin,
	type: :map,
	description: "Admin frontend",
	children: installed_frontend_options
	},
	%{
	key: :available,
	type: :map,
	description:
	"A map containing available frontends and parameters for their installation.",
	- children: [
	- frontend_options
	- ]
	+ children: frontend_options
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.Preload,
	type: :group,
	description: "Preload-related settings",
	children: [
	%{
	key: :providers,
	type: {:list, :module},
	description: "List of preload providers to enable",
	suggestions: [
	Pleroma.Web.Preload.Providers.Instance,
	Pleroma.Web.Preload.Providers.User,
	Pleroma.Web.Preload.Providers.Timelines,
	Pleroma.Web.Preload.Providers.StatusNet
	]
	}
	]
	}
	]
	diff --git a/config/test.exs b/config/test.exs
	index 93a0e2a61..95f860f2f 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,137 +1,135 @@
	use Mix.Config

	# We don't run a server during test. If one is required,
	# you can enable the server option below.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4001],
	url: [port: 4001],
	server: true

	# Disable captha for tests
	config :pleroma, Pleroma.Captcha,
	# It should not be enabled for automatic tests
	enabled: false,
	# A fake captcha service for tests
	method: Pleroma.Captcha.Mock

	# Print only warnings and errors during test
	config :logger, :console,
	level: :warn,
	format: "\n[$level] $message\n"

	config :pleroma, :fed_sockets,
	enabled: false,
	connection_duration: 5,
	rejection_duration: 5

	config :pleroma, :auth, oauth_consumer_strategies: []

	config :pleroma, Pleroma.Upload,
	filters: [],
	link_name: false,
	default_description: :filename

	config :pleroma, Pleroma.Uploaders.Local, uploads: "test/uploads"

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Test, enabled: true

	config :pleroma, :instance,
	email: "admin@example.com",
	notify_email: "noreply@example.com",
	skip_thread_containment: false,
	federating: false,
	external_user_synchronization: false,
	static_dir: "test/instance_static/"

	config :pleroma, :activitypub, sign_object_fetches: false

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_test",
	hostname: System.get_env("DB_HOST") \|\| "localhost",
	pool: Ecto.Adapters.SQL.Sandbox

	# Reduce hash rounds for testing
	config :pbkdf2_elixir, rounds: 1

	config :tesla, adapter: Tesla.Mock

	config :pleroma, :rich_media,
	enabled: false,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"]

	config :pleroma, :instance,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]

	config :web_push_encryption, :vapid_details,
	subject: "mailto:administrator@example.com",
	public_key:
	"BLH1qVhJItRGCfxgTtONfsOKDc9VRAraXw-3NsmjMngWSh7NxOizN6bkuRA7iLTMPS82PjwJAr3UoK9EC1IFrz4",
	private_key: "_-XZ0iebPrRfZ_o0-IatTdszYa8VCH1yLN-JauK7HHA"

	-config :web_push_encryption, :http_client, Pleroma.Web.WebPushHttpClientMock
	-
	config :pleroma, Oban,
	queues: false,
	crontab: false,
	plugins: false

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 2,
	total_user_limit: 3,
	enabled: false

	config :pleroma, :rate_limit, %{}

	config :pleroma, :http_security, report_uri: "https://endpoint.com"

	config :pleroma, :http, send_user_agent: false

	rum_enabled = System.get_env("RUM_ENABLED") == "true"
	config :pleroma, :database, rum_enabled: rum_enabled
	IO.puts("RUM enabled: #{rum_enabled}")

	config :joken, default_signer: "yU8uHKq+yyAkZ11Hx//jcdacWc8yQ1bxAAGrplzB0Zwwjkp35v0RK9SO8WTPr6QZ"

	config :pleroma, Pleroma.ReverseProxy.Client, Pleroma.ReverseProxy.ClientMock

	config :pleroma, :modules, runtime_dir: "test/fixtures/modules"

	config :pleroma, Pleroma.Gun, Pleroma.GunMock

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: true

	config :pleroma, Pleroma.Plugs.RemoteIp, enabled: false

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: true

	config :pleroma, Pleroma.Uploaders.S3,
	bucket: nil,
	streaming_enabled: true,
	public_endpoint: nil

	config :tzdata, :autoupdate, :disabled

	config :pleroma, :mrf, policies: []

	if File.exists?("./config/test.secret.exs") do
	import_config "test.secret.exs"
	else
	IO.puts(
	"You may want to create test.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/docs/API/admin_api.md b/docs/API/admin_api.md
	index 7992db58f..7bf13daef 100644
	--- a/docs/API/admin_api.md
	+++ b/docs/API/admin_api.md
	@@ -1,1499 +1,1499 @@
	# Admin API

	Authentication is required and the user must be an admin.

	Configuration options:

	* `[:auth, :enforce_oauth_admin_scope_usage]` — OAuth admin scope requirement toggle.
	If `true`, admin actions explicitly demand admin OAuth scope(s) presence in OAuth token (client app must support admin scopes).
	If `false` and token doesn't have admin scope(s), `is_admin` user flag grants access to admin-specific actions.
	Note that client app needs to explicitly support admin scopes and request them when obtaining auth token.

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

	### List users

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

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

	## DEPRECATED `DELETE /api/pleroma/admin/users`

	### Remove a user

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

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

	### Remove a user

	- Params:
	- `nicknames`
	- Response: Array of user nicknames

	### Create a user

	- Method: `POST`
	- Params:
	`users`: [
	{
	`nickname`,
	`email`,
	`password`
	}
	]
	- Response: User’s nickname

	## `POST /api/pleroma/admin/users/follow`

	### Make a user follow another user

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

	## `POST /api/pleroma/admin/users/unfollow`

	### Make a user unfollow another user

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

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

	### Toggle user activation

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

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

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

	### Tag a list of users

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

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

	### Untag a list of users

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

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

	### Get user user permission groups membership

	- Params: none
	- Response:

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

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

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

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

	- Params: none
	- Response:

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

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

	### Add user to permission group

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

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

	### Add users to permission group

	- Params:
	- `nicknames`: nicknames array
	- Response:
	- On failure: `{"error": "…"}`
	- On success: JSON of the user

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

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

	### Remove user from permission group

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

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

	### Remove users from permission group

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

	## `PATCH /api/pleroma/admin/users/activate`

	### Activate user

	- Params:
	- `nicknames`: nicknames array
	- Response:

	```json
	{
	users: [
	{
	// user object
	}
	]
	}
	```

	## `PATCH /api/pleroma/admin/users/deactivate`

	### Deactivate user

	- Params:
	- `nicknames`: nicknames array
	- Response:

	```json
	{
	users: [
	{
	// user object
	}
	]
	}
	```

	## `PATCH /api/pleroma/admin/users/approve`

	### Approve user

	- Params:
	- `nicknames`: nicknames array
	- Response:

	```json
	{
	users: [
	{
	// user object
	}
	]
	}
	```

	## `GET /api/pleroma/admin/users/:nickname_or_id`

	### Retrive the details of a user

	- Params:
	- `nickname` or `id`
	- Response:
	- On failure: `Not found`
	- On success: JSON of the user

	## `GET /api/pleroma/admin/users/:nickname_or_id/statuses`

	### Retrive user's latest statuses

	- Params:
	- `nickname` or `id`
	- optional `page_size`: number of statuses to return (default is `20`)
	- optional `godmode`: `true`/`false` – allows to see private statuses
	- optional `with_reblogs`: `true`/`false` – allows to see reblogs (default is false)
	- Response:
	- On failure: `Not found`
	- On success: JSON array of user's latest statuses

	## `GET /api/pleroma/admin/instances/:instance/statuses`

	### Retrive instance's latest statuses

	- Params:
	- `instance`: instance name
	- optional `page_size`: number of statuses to return (default is `20`)
	- optional `godmode`: `true`/`false` – allows to see private statuses
	- optional `with_reblogs`: `true`/`false` – allows to see reblogs (default is false)
	- Response:
	- On failure: `Not found`
	- On success: JSON array of instance's latest statuses

	## `GET /api/pleroma/admin/statuses`

	### Retrives all latest statuses

	- Params:
	- optional `page_size`: number of statuses to return (default is `20`)
	- optional `local_only`: excludes remote statuses
	- optional `godmode`: `true`/`false` – allows to see private statuses
	- optional `with_reblogs`: `true`/`false` – allows to see reblogs (default is false)
	- Response:
	- On failure: `Not found`
	- On success: JSON array of user's latest statuses

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

	### List Relays

	Params: none
	Response:

	* On success: JSON array of relays

	```json
	[
	{"actor": "https://example.com/relay", "followed_back": true},
	{"actor": "https://example2.com/relay", "followed_back": false}
	]
	```

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

	### Follow a Relay

	Params:

	* `relay_url`

	Response:

	* On success: relay json object

	```json
	{"actor": "https://example.com/relay", "followed_back": true}
	```

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

	### Unfollow a Relay

	-Params:
	-
	-* `relay_url`
	+- Params:
	+ - `relay_url`
	+ - optional `force`: forcefully unfollow a relay even when the relay is not available. (default is `false`)

	Response:

	* On success: URL of the unfollowed relay

	```json
	{"https://example.com/relay"}
	```

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

	### Create an account registration invite token

	- Params:
	- optional `max_use` (integer)
	- optional `expires_at` (date string e.g. "2019-04-07")
	- Response:

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

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

	### Get a list of generated invites

	- Params: none
	- Response:

	```json
	{

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

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

	### Revoke invite by token

	- Params:
	- `token`
	- Response:

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

	}
	```

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

	### Sends registration invite via email

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

	- Response:
	- On success: `204`, empty response
	- On failure:
	- 400 Bad Request, JSON:

	```json
	[
	{
	"error": "Appropriate error message here"
	}
	]
	```

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

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


	- Params: none
	- Response:

	```json
	{
	"token": "base64 reset token",
	"link": "https://pleroma.social/api/pleroma/password_reset/url-encoded-base64-token"
	}
	```

	## `PATCH /api/pleroma/admin/users/force_password_reset`

	### Force passord reset for a user with a given nickname

	- Params:
	- `nicknames`
	- Response: none (code `204`)

	## PUT `/api/pleroma/admin/users/disable_mfa`

	### Disable mfa for user's account.

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

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

	### Get the user's email, password, display and settings-related fields

	- Params:
	- `nickname`

	- Response:

	```json
	{
	"actor_type": "Person",
	"allow_following_move": true,
	"avatar": "https://pleroma.social/media/7e8e7508fd545ef580549b6881d80ec0ff2c81ed9ad37b9bdbbdf0e0d030159d.jpg",
	"background": "https://pleroma.social/media/4de34c0bd10970d02cbdef8972bef0ebbf55f43cadc449554d4396156162fe9a.jpg",
	"banner": "https://pleroma.social/media/8d92ba2bd244b613520abf557dd448adcd30f5587022813ee9dd068945986946.jpg",
	"bio": "bio",
	"default_scope": "public",
	"discoverable": false,
	"email": "user@example.com",
	"fields": [
	{
	"name": "example",
	"value": "<a href=\"https://example.com\" rel=\"ugc\">https://example.com</a>"
	}
	],
	"hide_favorites": false,
	"hide_followers": false,
	"hide_followers_count": false,
	"hide_follows": false,
	"hide_follows_count": false,
	"id": "9oouHaEEUR54hls968",
	"locked": true,
	"name": "user",
	"no_rich_text": true,
	"pleroma_settings_store": {},
	"raw_fields": [
	{
	"id": 1,
	"name": "example",
	"value": "https://example.com"
	},
	],
	"show_role": true,
	"skip_thread_containment": false
	}
	```

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

	### Change the user's email, password, display and settings-related fields

	* Params:
	* `email`
	* `password`
	* `name`
	* `bio`
	* `avatar`
	* `locked`
	* `no_rich_text`
	* `default_scope`
	* `banner`
	* `hide_follows`
	* `hide_followers`
	* `hide_followers_count`
	* `hide_follows_count`
	* `hide_favorites`
	* `allow_following_move`
	* `background`
	* `show_role`
	* `skip_thread_containment`
	* `fields`
	* `discoverable`
	* `actor_type`

	* Responses:

	Status: 200

	```json
	{"status": "success"}
	```

	Status: 400

	```json
	{"errors":
	{"actor_type": "is invalid"},
	{"email": "has invalid format"},
	...
	}
	```

	Status: 404

	```json
	{"error": "Not found"}
	```

	## `GET /api/pleroma/admin/reports`

	### Get a list of reports

	- Params:
	- optional `state`: string the state of reports. Valid values are `open`, `closed` and `resolved`
	- optional `limit`: integer the number of records to retrieve
	- optional `page`: integer page number
	- optional `page_size`: integer number of log entries per page (default is `50`)
	- Response:
	- On failure: 403 Forbidden error `{"error": "error_msg"}` when requested by anonymous or non-admin
	- On success: JSON, returns a list of reports, where:
	- `account`: the user who has been reported
	- `actor`: the user who has sent the report
	- `statuses`: list of statuses that have been included to the report

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

	## `GET /api/pleroma/admin/grouped_reports`

	### Get a list of reports, grouped by status

	- Params: none
	- On success: JSON, returns a list of reports, where:
	- `date`: date of the latest report
	- `account`: the user who has been reported (see `/api/pleroma/admin/reports` for reference)
	- `status`: reported status (see `/api/pleroma/admin/reports` for reference)
	- `actors`: users who had reported this status (see `/api/pleroma/admin/reports` for reference)
	- `reports`: reports (see `/api/pleroma/admin/reports` for reference)

	```json
	"reports": [
	{
	"date": "2019-10-07T12:31:39.615149Z",
	"account": { ... },
	"status": { ... },
	"actors": [{ ... }, { ... }],
	"reports": [{ ... }]
	}
	]
	```

	## `GET /api/pleroma/admin/reports/:id`

	### Get an individual report

	- Params:
	- `id`
	- Response:
	- On failure:
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, Report object (see above)

	## `PATCH /api/pleroma/admin/reports`

	### Change the state of one or multiple reports

	- Params:

	```json
	`reports`: [
	{
	`id`, // required, report id
	`state` // required, the new state. Valid values are `open`, `closed` and `resolved`
	},
	...
	]
	```

	- Response:
	- On failure:
	- 400 Bad Request, JSON:

	```json
	[
	{
	`id`, // report id
	`error` // error message
	}
	]
	```

	- On success: `204`, empty response

	## `POST /api/pleroma/admin/reports/:id/notes`

	### Create report note

	- Params:
	- `id`: required, report id
	- `content`: required, the message
	- Response:
	- On failure:
	- 400 Bad Request `"Invalid parameters"` when `status` is missing
	- On success: `204`, empty response

	## `DELETE /api/pleroma/admin/reports/:report_id/notes/:id`

	### Delete report note

	- Params:
	- `report_id`: required, report id
	- `id`: required, note id
	- Response:
	- On failure:
	- 400 Bad Request `"Invalid parameters"` when `status` is missing
	- On success: `204`, empty response

	## `GET /api/pleroma/admin/statuses/:id`

	### Show status by id

	- Params:
	- `id`: required, status id
	- Response:
	- On failure:
	- 404 Not Found `"Not Found"`
	- On success: JSON, Mastodon Status entity

	## `PUT /api/pleroma/admin/statuses/:id`

	### Change the scope of an individual reported status

	- Params:
	- `id`
	- `sensitive`: optional, valid values are `true` or `false`
	- `visibility`: optional, valid values are `public`, `private` and `unlisted`
	- Response:
	- On failure:
	- 400 Bad Request `"Unsupported visibility"`
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, Mastodon Status entity

	## `DELETE /api/pleroma/admin/statuses/:id`

	### Delete an individual reported status

	- Params:
	- `id`
	- Response:
	- On failure:
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: 200 OK `{}`

	## `GET /api/pleroma/admin/restart`

	### Restarts pleroma application

	Only works when configuration from database is enabled.

	- Params: none
	- Response:
	- On failure:
	- 400 Bad Request `"To use this endpoint you need to enable configuration from database."`

	```json
	{}
	```

	## `GET /api/pleroma/admin/need_reboot`

	### Returns the flag whether the pleroma should be restarted

	- Params: none
	- Response:
	- `need_reboot` - boolean
	```json
	{
	"need_reboot": false
	}
	```

	## `GET /api/pleroma/admin/config`

	### Get list of merged default settings with saved in database.

	If `need_reboot` is `true`, instance must be restarted, so reboot time settings can take effect.

	Only works when configuration from database is enabled.

	- Params:
	- `only_db`: true (optional, get only saved in database settings)
	- Response:
	- On failure:
	- 400 Bad Request `"To use this endpoint you need to enable configuration from database."`

	```json
	{
	"configs": [
	{
	"group": ":pleroma",
	"key": "Pleroma.Upload",
	"value": []
	}
	],
	"need_reboot": true
	}
	```

	## `POST /api/pleroma/admin/config`

	### Update config settings

	If `need_reboot` is `true`, instance must be restarted, so reboot time settings can take effect.

	Only works when configuration from database is enabled.

	Some modifications are necessary to save the config settings correctly:

	- strings which start with `Pleroma.`, `Phoenix.`, `Tesla.` or strings like `Oban`, `Ueberauth` will be converted to modules;
	```
	"Pleroma.Upload" -> Pleroma.Upload
	"Oban" -> Oban
	```
	- strings starting with `:` will be converted to atoms;
	```
	":pleroma" -> :pleroma
	```
	- objects with `tuple` key and array value will be converted to tuples;
	```
	{"tuple": ["string", "Pleroma.Upload", []]} -> {"string", Pleroma.Upload, []}
	```
	- arrays with tuple objects will be converted to keywords;
	```
	[{"tuple": [":key1", "value"]}, {"tuple": [":key2", "value"]}] -> [key1: "value", key2: "value"]
	```

	Most of the settings will be applied in `runtime`, this means that you don't need to restart the instance. But some settings are applied in `compile time` and require a reboot of the instance, such as:
	- all settings inside these keys:
	- `:hackney_pools`
	- `:connections_pool`
	- `:pools`
	- `:chat`
	- partially settings inside these keys:
	- `:seconds_valid` in `Pleroma.Captcha`
	- `:proxy_remote` in `Pleroma.Upload`
	- `:upload_limit` in `:instance`

	- Params:
	- `configs` - array of config objects
	- config object params:
	- `group` - string (required)
	- `key` - string (required)
	- `value` - string, [], {} or {"tuple": []} (required)
	- `delete` - true (optional, if setting must be deleted)
	- `subkeys` - array of strings (optional, only works when `delete=true` parameter is passed, otherwise will be ignored)

	When a value have several nested settings, you can delete only some nested settings by passing a parameter `subkeys`, without deleting all settings by key.
	```
	[subkey: val1, subkey2: val2, subkey3: val3] \\ initial value
	{"group": ":pleroma", "key": "some_key", "delete": true, "subkeys": [":subkey", ":subkey3"]} \\ passing json for deletion
	[subkey2: val2] \\ value after deletion
	```

	Most of the settings can be partially updated through merge old values with new values, except settings value of which is list or is not keyword.

	Example of setting without keyword in value:
	```elixir
	config :tesla, :adapter, Tesla.Adapter.Hackney
	```

	List of settings which support only full update by key:
	```elixir
	@full_key_update [
	{:pleroma, :ecto_repos},
	{:quack, :meta},
	{:mime, :types},
	{:cors_plug, [:max_age, :methods, :expose, :headers]},
	{:auto_linker, :opts},
	{:swarm, :node_blacklist},
	{:logger, :backends}
	]
	```

	List of settings which support only full update by subkey:
	```elixir
	@full_subkey_update [
	{:pleroma, :assets, :mascots},
	{:pleroma, :emoji, :groups},
	{:pleroma, :workers, :retries},
	{:pleroma, :mrf_subchain, :match_actor},
	{:pleroma, :mrf_keyword, :replace}
	]
	```

	Settings without explicit key must be sended in separate config object params.
	```elixir
	config :quack,
	level: :debug,
	meta: [:all],
	...
	```
	```json
	{
	"configs": [
	{"group": ":quack", "key": ":level", "value": ":debug"},
	{"group": ":quack", "key": ":meta", "value": [":all"]},
	...
	]
	}
	```
	- Request:

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

	- Response:
	- On failure:
	- 400 Bad Request `"To use this endpoint you need to enable configuration from database."`
	```json
	{
	"configs": [
	{
	"group": ":pleroma",
	"key": "Pleroma.Upload",
	"value": [...]
	}
	],
	"need_reboot": true
	}
	```

	## ` GET /api/pleroma/admin/config/descriptions`

	### Get JSON with config descriptions.
	Loads json generated from `config/descriptions.exs`.

	- Params: none
	- Response:

	```json
	[{
	"group": ":pleroma", // string
	"key": "ModuleName", // string
	"type": "group", // string or list with possible values,
	"description": "Upload general settings", // string
	"children": [
	{
	"key": ":uploader", // string or module name `Pleroma.Upload`
	"type": "module",
	"description": "Module which will be used for uploads",
	"suggestions": ["module1", "module2"]
	},
	{
	"key": ":filters",
	"type": ["list", "module"],
	"description": "List of filter modules for uploads",
	"suggestions": [
	"module1", "module2", "module3"
	]
	}
	]
	}]
	```

	## `GET /api/pleroma/admin/moderation_log`

	### Get moderation log

	- Params:
	- optional `page`: integer page number
	- optional `page_size`: integer number of log entries per page (default is `50`)
	- optional `start_date`: datetime (ISO 8601) filter logs by creation date, start from `start_date`. Accepts datetime in ISO 8601 format (YYYY-MM-DDThh:mm:ss), e.g. `2005-08-09T18:31:42`
	- optional `end_date`: datetime (ISO 8601) filter logs by creation date, end by from `end_date`. Accepts datetime in ISO 8601 format (YYYY-MM-DDThh:mm:ss), e.g. 2005-08-09T18:31:42
	- optional `user_id`: integer filter logs by actor's id
	- optional `search`: string search logs by the log message
	- Response:

	```json
	[
	{
	"data": {
	"actor": {
	"id": 1,
	"nickname": "lain"
	},
	"action": "relay_follow"
	},
	"time": 1502812026, // timestamp
	"message": "[2017-08-15 15:47:06] @nick0 followed relay: https://example.org/relay" // log message
	}
	]
	```

	## `POST /api/pleroma/admin/reload_emoji`

	### Reload the instance's custom emoji

	- Authentication: required
	- Params: None
	- Response: JSON, "ok" and 200 status

	## `PATCH /api/pleroma/admin/users/confirm_email`

	### Confirm users' emails

	- Params:
	- `nicknames`
	- Response: Array of user nicknames

	## `PATCH /api/pleroma/admin/users/resend_confirmation_email`

	### Resend confirmation email

	- Params:
	- `nicknames`
	- Response: Array of user nicknames

	## `GET /api/pleroma/admin/stats`

	### Stats

	- Query Params:
	- optional `instance`: string instance hostname (without protocol) to get stats for
	- Example: `https://mypleroma.org/api/pleroma/admin/stats?instance=lain.com`

	- Response:

	```json
	{
	"status_visibility": {
	"direct": 739,
	"private": 9,
	"public": 17,
	"unlisted": 14
	}
	}
	```

	## `GET /api/pleroma/admin/oauth_app`

	### List OAuth app

	- Params:
	- optional `name`
	- optional `client_id`
	- optional `page`
	- optional `page_size`
	- optional `trusted`

	- Response:

	```json
	{
	"apps": [
	{
	"id": 1,
	"name": "App name",
	"client_id": "yHoDSiWYp5mPV6AfsaVOWjdOyt5PhWRiafi6MRd1lSk",
	"client_secret": "nLmis486Vqrv2o65eM9mLQx_m_4gH-Q6PcDpGIMl6FY",
	"redirect_uri": "https://example.com/oauth-callback",
	"website": "https://example.com",
	"trusted": true
	}
	],
	"count": 17,
	"page_size": 50
	}
	```


	## `POST /api/pleroma/admin/oauth_app`

	### Create OAuth App

	- Params:
	- `name`
	- `redirect_uris`
	- `scopes`
	- optional `website`
	- optional `trusted`

	- Response:

	```json
	{
	"id": 1,
	"name": "App name",
	"client_id": "yHoDSiWYp5mPV6AfsaVOWjdOyt5PhWRiafi6MRd1lSk",
	"client_secret": "nLmis486Vqrv2o65eM9mLQx_m_4gH-Q6PcDpGIMl6FY",
	"redirect_uri": "https://example.com/oauth-callback",
	"website": "https://example.com",
	"trusted": true
	}
	```

	- On failure:
	```json
	{
	"redirect_uris": "can't be blank",
	"name": "can't be blank"
	}
	```

	## `PATCH /api/pleroma/admin/oauth_app/:id`

	### Update OAuth App

	- Params:
	- optional `name`
	- optional `redirect_uris`
	- optional `scopes`
	- optional `website`
	- optional `trusted`

	- Response:

	```json
	{
	"id": 1,
	"name": "App name",
	"client_id": "yHoDSiWYp5mPV6AfsaVOWjdOyt5PhWRiafi6MRd1lSk",
	"client_secret": "nLmis486Vqrv2o65eM9mLQx_m_4gH-Q6PcDpGIMl6FY",
	"redirect_uri": "https://example.com/oauth-callback",
	"website": "https://example.com",
	"trusted": true
	}
	```

	## `DELETE /api/pleroma/admin/oauth_app/:id`

	### Delete OAuth App

	- Params: None

	- Response:
	- On success: `204`, empty response
	- On failure:
	- 400 Bad Request `"Invalid parameters"` when `status` is missing

	## `GET /api/pleroma/admin/media_proxy_caches`

	### Get a list of all banned MediaProxy URLs in Cachex

	- Authentication: required
	- Params:
	- optional `page`: integer page number
	- optional `page_size`: integer number of log entries per page (default is `50`)
	- optional `query`: string search term

	- Response:

	``` json
	{
	"page_size": integer,
	"count": integer,
	"urls": [
	"http://example.com/media/a688346.jpg",
	"http://example.com/media/fb1f4d.jpg"
	]
	}

	```

	## `POST /api/pleroma/admin/media_proxy_caches/delete`

	### Remove a banned MediaProxy URL from Cachex

	- Authentication: required
	- Params:
	- `urls` (array)

	- Response:

	``` json
	{ }

	```

	## `POST /api/pleroma/admin/media_proxy_caches/purge`

	### Purge a MediaProxy URL

	- Authentication: required
	- Params:
	- `urls` (array)
	- `ban` (boolean)

	- Response:

	``` json
	{ }

	```

	## GET /api/pleroma/admin/users/:nickname/chats

	### List a user's chats

	- Params: None

	- Response:

	```json
	[
	{
	"sender": {
	"id": "someflakeid",
	"username": "somenick",
	...
	},
	"receiver": {
	"id": "someflakeid",
	"username": "somenick",
	...
	},
	"id" : "1",
	"unread" : 2,
	"last_message" : {...}, // The last message in that chat
	"updated_at": "2020-04-21T15:11:46.000Z"
	}
	]
	```

	## GET /api/pleroma/admin/chats/:chat_id

	### View a single chat

	- Params: None

	- Response:

	```json
	{
	"sender": {
	"id": "someflakeid",
	"username": "somenick",
	...
	},
	"receiver": {
	"id": "someflakeid",
	"username": "somenick",
	...
	},
	"id" : "1",
	"unread" : 2,
	"last_message" : {...}, // The last message in that chat
	"updated_at": "2020-04-21T15:11:46.000Z"
	}
	```

	## GET /api/pleroma/admin/chats/:chat_id/messages

	### List the messages in a chat

	- Params: `max_id`, `min_id`

	- Response:

	```json
	[
	{
	"account_id": "someflakeid",
	"chat_id": "1",
	"content": "Check this out :firefox:",
	"created_at": "2020-04-21T15:11:46.000Z",
	"emojis": [
	{
	"shortcode": "firefox",
	"static_url": "https://dontbulling.me/emoji/Firefox.gif",
	"url": "https://dontbulling.me/emoji/Firefox.gif",
	"visible_in_picker": false
	}
	],
	"id": "13",
	"unread": true
	},
	{
	"account_id": "someflakeid",
	"chat_id": "1",
	"content": "Whats' up?",
	"created_at": "2020-04-21T15:06:45.000Z",
	"emojis": [],
	"id": "12",
	"unread": false
	}
	]
	```

	## DELETE /api/pleroma/admin/chats/:chat_id/messages/:message_id

	### Delete a single message

	- Params: None

	- Response:

	```json
	{
	"account_id": "someflakeid",
	"chat_id": "1",
	"content": "Check this out :firefox:",
	"created_at": "2020-04-21T15:11:46.000Z",
	"emojis": [
	{
	"shortcode": "firefox",
	"static_url": "https://dontbulling.me/emoji/Firefox.gif",
	"url": "https://dontbulling.me/emoji/Firefox.gif",
	"visible_in_picker": false
	}
	],
	"id": "13",
	"unread": false
	}
	```

	## `GET /api/pleroma/admin/instance_document/:document_name`

	### Get an instance document

	- Authentication: required

	- Response:

	Returns the content of the document

	```html
	<h1>Instance panel</h1>
	```

	## `PATCH /api/pleroma/admin/instance_document/:document_name`
	- Params:
	- `file` (the file to be uploaded, using multipart form data.)

	### Update an instance document

	- Authentication: required

	- Response:

	``` json
	{
	"url": "https://example.com/instance/panel.html"
	}
	```

	## `DELETE /api/pleroma/admin/instance_document/:document_name`

	### Delete an instance document

	- Response:

	``` json
	{
	"url": "https://example.com/instance/panel.html"
	}
	```
	diff --git a/docs/API/pleroma_api.md b/docs/API/pleroma_api.md
	index 94b6a4fda..3fd141bd2 100644
	--- a/docs/API/pleroma_api.md
	+++ b/docs/API/pleroma_api.md
	@@ -1,588 +1,617 @@
	# Pleroma API

	Requests that require it can be authenticated with [an OAuth token](https://tools.ietf.org/html/rfc6749), the `_pleroma_key` cookie, or [HTTP Basic Authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization).

	Request parameters can be passed via [query strings](https://en.wikipedia.org/wiki/Query_string) or as [form data](https://www.w3.org/TR/html401/interact/forms.html). Files must be uploaded as `multipart/form-data`.

	## `/api/pleroma/emoji`
	### Lists the custom emoji on that server.
	* Method: `GET`
	* Authentication: not required
	* Params: none
	* Response: JSON
	* Example response:
	```json
	{
	"girlpower": {
	"tags": [
	"Finmoji"
	],
	"image_url": "/finmoji/128px/girlpower-128.png"
	},
	"education": {
	"tags": [
	"Finmoji"
	],
	"image_url": "/finmoji/128px/education-128.png"
	},
	"finnishlove": {
	"tags": [
	"Finmoji"
	],
	"image_url": "/finmoji/128px/finnishlove-128.png"
	}
	}
	```
	* Note: Same data as Mastodon API’s `/api/v1/custom_emojis` but in a different format

	## `/api/pleroma/follow_import`
	### Imports your follows, for example from a Mastodon CSV file.
	* Method: `POST`
	* Authentication: required
	* Params:
	* `list`: STRING or FILE containing a whitespace-separated list of accounts to follow
	* Response: HTTP 200 on success, 500 on error
	* Note: Users that can't be followed are silently skipped.

	## `/api/pleroma/blocks_import`
	### Imports your blocks.
	* Method: `POST`
	* Authentication: required
	* Params:
	* `list`: STRING or FILE containing a whitespace-separated list of accounts to block
	* Response: HTTP 200 on success, 500 on error

	## `/api/pleroma/mutes_import`
	### Imports your mutes.
	* Method: `POST`
	* Authentication: required
	* Params:
	* `list`: STRING or FILE containing a whitespace-separated list of accounts to mute
	* Response: HTTP 200 on success, 500 on error

	## `/api/pleroma/captcha`
	### Get a new captcha
	* Method: `GET`
	* Authentication: not required
	* Params: none
	* Response: Provider specific JSON, the only guaranteed parameter is `type`
	* Example response: `{"type": "kocaptcha", "token": "whatever", "url": "https://captcha.kotobank.ch/endpoint", "seconds_valid": 300}`

	## `/api/pleroma/delete_account`
	### Delete an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{"status": "success"}` if the deletion was successful, `{"error": "[error message]"}` otherwise
	* Example response: `{"error": "Invalid password."}`

	## `/api/pleroma/disable_account`
	### Disable an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{"status": "success"}` if the account was successfully disabled, `{"error": "[error message]"}` otherwise
	* Example response: `{"error": "Invalid password."}`

	## `/api/pleroma/accounts/mfa`
	#### Gets current MFA settings
	* method: `GET`
	* Authentication: required
	* OAuth scope: `read:security`
	* Response: JSON. Returns `{"enabled": "false", "totp": false }`

	## `/api/pleroma/accounts/mfa/setup/totp`
	#### Pre-setup the MFA/TOTP method
	* method: `GET`
	* Authentication: required
	* OAuth scope: `write:security`
	* Response: JSON. Returns `{"key": [secret_key], "provisioning_uri": "[qr code uri]" }` when successful, otherwise returns HTTP 422 `{"error": "error_msg"}`

	## `/api/pleroma/accounts/mfa/confirm/totp`
	#### Confirms & enables MFA/TOTP support for user account.
	* method: `POST`
	* Authentication: required
	* OAuth scope: `write:security`
	* Params:
	* `password`: user's password
	* `code`: token from TOTP App
	* Response: JSON. Returns `{}` if the enable was successful, HTTP 422 `{"error": "[error message]"}` otherwise


	## `/api/pleroma/accounts/mfa/totp`
	#### Disables MFA/TOTP method for user account.
	* method: `DELETE`
	* Authentication: required
	* OAuth scope: `write:security`
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{}` if the disable was successful, HTTP 422 `{"error": "[error message]"}` otherwise
	* Example response: `{"error": "Invalid password."}`

	## `/api/pleroma/accounts/mfa/backup_codes`
	#### Generstes backup codes MFA for user account.
	* method: `GET`
	* Authentication: required
	* OAuth scope: `write:security`
	* Response: JSON. Returns `{"codes": codes}`when successful, otherwise HTTP 422 `{"error": "[error message]"}`

	## `/api/pleroma/admin/`
	See [Admin-API](admin_api.md)

	## `/api/v1/pleroma/notifications/read`
	### Mark notifications as read
	* Method `POST`
	* Authentication: required
	* Params (mutually exclusive):
	* `id`: a single notification id to read
	* `max_id`: read all notifications up to this id
	* Response: Notification entity/Array of Notification entities that were read. In case of `max_id`, only the first 80 read notifications will be returned.

	## `/api/v1/pleroma/accounts/:id/subscribe`
	### Subscribe to receive notifications for all statuses posted by a user
	* Method `POST`
	* Authentication: required
	* Params:
	* `id`: account id to subscribe to
	* Response: JSON, returns a mastodon relationship object on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```json
	{
	"id": "abcdefg",
	"following": true,
	"followed_by": false,
	"blocking": false,
	"muting": false,
	"muting_notifications": false,
	"subscribing": true,
	"requested": false,
	"domain_blocking": false,
	"showing_reblogs": true,
	"endorsed": false
	}
	```

	## `/api/v1/pleroma/accounts/:id/unsubscribe`
	### Unsubscribe to stop receiving notifications from user statuses
	* Method `POST`
	* Authentication: required
	* Params:
	* `id`: account id to unsubscribe from
	* Response: JSON, returns a mastodon relationship object on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```json
	{
	"id": "abcdefg",
	"following": true,
	"followed_by": false,
	"blocking": false,
	"muting": false,
	"muting_notifications": false,
	"subscribing": false,
	"requested": false,
	"domain_blocking": false,
	"showing_reblogs": true,
	"endorsed": false
	}
	```

	## `/api/v1/pleroma/accounts/:id/favourites`
	### Returns favorites timeline of any user
	* Method `GET`
	* Authentication: not required
	* Params:
	* `id`: the id of the account for whom to return results
	* `limit`: optional, the number of records to retrieve
	* `since_id`: optional, returns results that are more recent than the specified id
	* `max_id`: optional, returns results that are older than the specified id
	* Response: JSON, returns a list of Mastodon Status entities on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```json
	[
	{
	"account": {
	"id": "9hptFmUF3ztxYh3Svg",
	"url": "https://pleroma.example.org/users/nick2",
	"username": "nick2",
	...
	},
	"application": {"name": "Web", "website": null},
	"bookmarked": false,
	"card": null,
	"content": "This is :moominmamma: note 0",
	"created_at": "2019-04-15T15:42:15.000Z",
	"emojis": [],
	"favourited": false,
	"favourites_count": 1,
	"id": "9hptFmVJ02khbzYJaS",
	"in_reply_to_account_id": null,
	"in_reply_to_id": null,
	"language": null,
	"media_attachments": [],
	"mentions": [],
	"muted": false,
	"pinned": false,
	"pleroma": {
	"content": {"text/plain": "This is :moominmamma: note 0"},
	"conversation_id": 13679,
	"local": true,
	"spoiler_text": {"text/plain": "2hu"}
	},
	"reblog": null,
	"reblogged": false,
	"reblogs_count": 0,
	"replies_count": 0,
	"sensitive": false,
	"spoiler_text": "2hu",
	"tags": [{"name": "2hu", "url": "/tag/2hu"}],
	"uri": "https://pleroma.example.org/objects/198ed2a1-7912-4482-b559-244a0369e984",
	"url": "https://pleroma.example.org/notice/9hptFmVJ02khbzYJaS",
	"visibility": "public"
	}
	]
	```

	## `/api/v1/pleroma/accounts/update_*`
	### Set and clear account avatar, banner, and background

	- PATCH `/api/v1/pleroma/accounts/update_avatar`: Set/clear user avatar image
	- PATCH `/api/v1/pleroma/accounts/update_banner`: Set/clear user banner image
	- PATCH `/api/v1/pleroma/accounts/update_background`: Set/clear user background image

	## `/api/v1/pleroma/accounts/confirmation_resend`
	### Resend confirmation email
	* Method `POST`
	* Params:
	* `email`: email of that needs to be verified
	* Authentication: not required
	* Response: 204 No Content

	## `/api/v1/pleroma/mascot`
	### Gets user mascot image
	* Method `GET`
	* Authentication: required

	* Response: JSON. Returns a mastodon media attachment entity.
	* Example response:
	```json
	{
	"id": "abcdefg",
	"url": "https://pleroma.example.org/media/abcdefg.png",
	"type": "image",
	"pleroma": {
	"mime_type": "image/png"
	}
	}
	```

	### Updates user mascot image
	* Method `PUT`
	* Authentication: required
	* Params:
	* `file`: Multipart image
	* Response: JSON. Returns a mastodon media attachment entity
	when successful, otherwise returns HTTP 415 `{"error": "error_msg"}`
	* Example response:
	```json
	{
	"id": "abcdefg",
	"url": "https://pleroma.example.org/media/abcdefg.png",
	"type": "image",
	"pleroma": {
	"mime_type": "image/png"
	}
	}
	```
	* Note: Behaves exactly the same as `POST /api/v1/upload`.
	Can only accept images - any attempt to upload non-image files will be met with `HTTP 415 Unsupported Media Type`.

	## `/api/pleroma/notification_settings`
	### Updates user notification settings
	* Method `PUT`
	* Authentication: required
	* Params:
	* `block_from_strangers`: BOOLEAN field, blocks notifications from accounts you do not follow
	* `hide_notification_contents`: BOOLEAN field. When set to true, it removes the contents of a message from the push notification.
	* Response: JSON. Returns `{"status": "success"}` if the update was successful, otherwise returns `{"error": "error_msg"}`

	## `/api/pleroma/healthcheck`
	### Healthcheck endpoint with additional system data.
	* Method `GET`
	* Authentication: not required
	* Params: none
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).
	* Example response:
	```json
	{
	"pool_size": 0, # database connection pool
	"active": 0, # active processes
	"idle": 0, # idle processes
	"memory_used": 0.00, # Memory used
	"healthy": true, # Instance state
	"job_queue_stats": {} # Job queue stats
	}
	```

	## `/api/pleroma/change_email`
	### Change account email
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* `email`: new email
	* Response: JSON. Returns `{"status": "success"}` if the change was successful, `{"error": "[error message]"}` otherwise
	* Note: Currently, Mastodon has no API for changing email. If they add it in future it might be incompatible with Pleroma.

	# Pleroma Conversations

	Pleroma Conversations have the same general structure that Mastodon Conversations have. The behavior differs in the following ways when using these endpoints:

	1. Pleroma Conversations never add or remove recipients, unless explicitly changed by the user.
	2. Pleroma Conversations statuses can be requested by Conversation id.
	3. Pleroma Conversations can be replied to.

	Conversations have the additional field `recipients` under the `pleroma` key. This holds a list of all the accounts that will receive a message in this conversation.

	The status posting endpoint takes an additional parameter, `in_reply_to_conversation_id`, which, when set, will set the visiblity to direct and address only the people who are the recipients of that Conversation.

	⚠ Conversation IDs can be found in direct messages with the `pleroma.direct_conversation_id` key, do not confuse it with `pleroma.conversation_id`.

	## `GET /api/v1/pleroma/conversations/:id/statuses`
	### Timeline for a given conversation
	* Method `GET`
	* Authentication: required
	* Params: Like other timelines
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).

	## `GET /api/v1/pleroma/conversations/:id`
	### The conversation with the given ID.
	* Method `GET`
	* Authentication: required
	* Params: None
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).

	## `PATCH /api/v1/pleroma/conversations/:id`
	### Update a conversation. Used to change the set of recipients.
	* Method `PATCH`
	* Authentication: required
	* Params:
	* `recipients`: A list of ids of users that should receive posts to this conversation. This will replace the current list of recipients, so submit the full list. The owner of owner of the conversation will always be part of the set of recipients, though.
	* Response: JSON, statuses (200 - healthy, 503 unhealthy)

	## `POST /api/v1/pleroma/conversations/read`
	### Marks all user's conversations as read.
	* Method `POST`
	* Authentication: required
	* Params: None
	* Response: JSON, returns a list of Mastodon Conversation entities that were marked as read (200 - healthy, 503 unhealthy).

	-## `GET /api/pleroma/emoji/packs/import`
	-### Imports packs from filesystem
	-* Method `GET`
	-* Authentication: required
	-* Params: None
	-* Response: JSON, returns a list of imported packs.
	+## `GET /api/pleroma/emoji/pack?name=:name`
	+
	+### Get pack.json for the pack

	-## `GET /api/pleroma/emoji/packs/remote`
	-### Make request to another instance for packs list
	* Method `GET`
	-* Authentication: required
	+* Authentication: not required
	* Params:
	- * `url`: url of the instance to get packs from
	-* Response: JSON with the pack list, hashmap with pack name and pack contents
	+ * `page`: page number for files (default 1)
	+ * `page_size`: page size for files (default 30)
	+* Response: JSON, pack json with `files`, `files_count` and `pack` keys with 200 status or 404 if the pack does not exist.

	-## `POST /api/pleroma/emoji/packs/download`
	-### Download pack from another instance
	-* Method `POST`
	-* Authentication: required
	-* Params:
	- * `url`: url of the instance to download from
	- * `name`: pack to download from that instance
	- * `as`: (optional) name how to save pack
	-* Response: JSON, "ok" with 200 status if the pack was downloaded, or 500 if there were
	- errors downloading the pack
	+```json
	+{
	+ "files": {...},
	+ "files_count": 0, // emoji count in pack
	+ "pack": {...}
	+}
	+```
	+
	+## `POST /api/pleroma/emoji/pack?name=:name`

	-## `POST /api/pleroma/emoji/packs/:name`
	### Creates an empty pack
	+
	* Method `POST`
	-* Authentication: required
	-* Params: None
	+* Authentication: required (admin)
	+* Params:
	+ * `name`: pack name
	* Response: JSON, "ok" and 200 status or 409 if the pack with that name already exists

	-## `PATCH /api/pleroma/emoji/packs/:name`
	+## `PATCH /api/pleroma/emoji/pack?name=:name`
	+
	### Updates (replaces) pack metadata
	+
	* Method `PATCH`
	-* Authentication: required
	+* Authentication: required (admin)
	* Params:
	+ * `name`: pack name
	* `metadata`: metadata to replace the old one
	* `license`: Pack license
	* `homepage`: Pack home page url
	* `description`: Pack description
	* `fallback-src`: Fallback url to download pack from
	* `fallback-src-sha256`: SHA256 encoded for fallback pack archive
	* `share-files`: is pack allowed for sharing (boolean)
	* Response: JSON, updated "metadata" section of the pack and 200 status or 400 if there was a
	problem with the new metadata (the error is specified in the "error" part of the response JSON)

	-## `DELETE /api/pleroma/emoji/packs/:name`
	+## `DELETE /api/pleroma/emoji/pack?name=:name`
	+
	### Delete a custom emoji pack
	+
	* Method `DELETE`
	-* Authentication: required
	-* Params: None
	+* Authentication: required (admin)
	+* Params:
	+ * `name`: pack name
	* Response: JSON, "ok" and 200 status or 500 if there was an error deleting the pack

	-## `POST /api/pleroma/emoji/packs/:name/files`
	+## `GET /api/pleroma/emoji/packs/import`
	+
	+### Imports packs from filesystem
	+
	+* Method `GET`
	+* Authentication: required (admin)
	+* Params: None
	+* Response: JSON, returns a list of imported packs.
	+
	+## `GET /api/pleroma/emoji/packs/remote`
	+
	+### Make request to another instance for packs list
	+
	+* Method `GET`
	+* Authentication: required (admin)
	+* Params:
	+ * `url`: url of the instance to get packs from
	+ * `page`: page number for packs (default 1)
	+ * `page_size`: page size for packs (default 50)
	+* Response: JSON with the pack list, hashmap with pack name and pack contents
	+
	+## `POST /api/pleroma/emoji/packs/download`
	+
	+### Download pack from another instance
	+
	+* Method `POST`
	+* Authentication: required (admin)
	+* Params:
	+ * `url`: url of the instance to download from
	+ * `name`: pack to download from that instance
	+ * `as`: (optional) name how to save pack
	+* Response: JSON, "ok" with 200 status if the pack was downloaded, or 500 if there were
	+ errors downloading the pack
	+
	+## `POST /api/pleroma/emoji/packs/files?name=:name`
	+
	### Add new file to the pack
	+
	* Method `POST`
	-* Authentication: required
	+* Authentication: required (admin)
	* Params:
	+ * `name`: pack name
	* `file`: file needs to be uploaded with the multipart request or link to remote file.
	* `shortcode`: (optional) shortcode for new emoji, must be unique for all emoji. If not sended, shortcode will be taken from original filename.
	* `filename`: (optional) new emoji file name. If not specified will be taken from original filename.
	* Response: JSON, list of files for updated pack (hashmap -> shortcode => filename) with status 200, either error status with error message.

	-## `PATCH /api/pleroma/emoji/packs/:name/files`
	+## `PATCH /api/pleroma/emoji/packs/files?name=:name`
	+
	### Update emoji file from pack
	+
	* Method `PATCH`
	-* Authentication: required
	+* Authentication: required (admin)
	* Params:
	+ * `name`: pack name
	* `shortcode`: emoji file shortcode
	* `new_shortcode`: new emoji file shortcode
	* `new_filename`: new filename for emoji file
	* `force`: (optional) with true value to overwrite existing emoji with new shortcode
	* Response: JSON, list with updated files for updated pack (hashmap -> shortcode => filename) with status 200, either error status with error message.

	-## `DELETE /api/pleroma/emoji/packs/:name/files`
	+## `DELETE /api/pleroma/emoji/packs/files?name=:name`
	+
	### Delete emoji file from pack
	+
	* Method `DELETE`
	-* Authentication: required
	+* Authentication: required (admin)
	* Params:
	+ * `name`: pack name
	* `shortcode`: emoji file shortcode
	* Response: JSON, list with updated files for updated pack (hashmap -> shortcode => filename) with status 200, either error status with error message.

	## `GET /api/pleroma/emoji/packs`

	### Lists local custom emoji packs

	* Method `GET`
	* Authentication: not required
	* Params:
	* `page`: page number for packs (default 1)
	* `page_size`: page size for packs (default 50)
	* Response: `packs` key with JSON hashmap of pack name to pack contents and `count` key for count of packs.

	```json
	{
	"packs": {
	"pack_name": {...}, // pack contents
	...
	},
	"count": 0 // packs count
	}
	```

	-## `GET /api/pleroma/emoji/packs/:name`
	+## `GET /api/pleroma/emoji/packs/archive?name=:name`

	-### Get pack.json for the pack
	+### Requests a local pack archive from the instance

	* Method `GET`
	* Authentication: not required
	* Params:
	- * `page`: page number for files (default 1)
	- * `page_size`: page size for files (default 30)
	-* Response: JSON, pack json with `files`, `files_count` and `pack` keys with 200 status or 404 if the pack does not exist.
	-
	-```json
	-{
	- "files": {...},
	- "files_count": 0, // emoji count in pack
	- "pack": {...}
	-}
	-```
	-
	-## `GET /api/pleroma/emoji/packs/:name/archive`
	-### Requests a local pack archive from the instance
	-* Method `GET`
	-* Authentication: not required
	-* Params: None
	+ * `name`: pack name
	* Response: the archive of the pack with a 200 status code, 403 if the pack is not set as shared,
	404 if the pack does not exist

	## `GET /api/v1/pleroma/accounts/:id/scrobbles`
	### Requests a list of current and recent Listen activities for an account
	* Method `GET`
	* Authentication: not required
	* Params: None
	* Response: An array of media metadata entities.
	* Example response:
	```json
	[
	{
	"account": {...},
	"id": "1234",
	"title": "Some Title",
	"artist": "Some Artist",
	"album": "Some Album",
	"length": 180000,
	"created_at": "2019-09-28T12:40:45.000Z"
	}
	]
	```

	## `POST /api/v1/pleroma/scrobble`
	### Creates a new Listen activity for an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `title`: the title of the media playing
	* `album`: the album of the media playing [optional]
	* `artist`: the artist of the media playing [optional]
	* `length`: the length of the media playing [optional]
	* Response: the newly created media metadata entity representing the Listen activity

	# Emoji Reactions

	Emoji reactions work a lot like favourites do. They make it possible to react to a post with a single emoji character. To detect the presence of this feature, you can check `pleroma_emoji_reactions` entry in the features list of nodeinfo.

	## `PUT /api/v1/pleroma/statuses/:id/reactions/:emoji`
	### React to a post with a unicode emoji
	* Method: `PUT`
	* Authentication: required
	* Params: `emoji`: A single character unicode emoji
	* Response: JSON, the status.

	## `DELETE /api/v1/pleroma/statuses/:id/reactions/:emoji`
	### Remove a reaction to a post with a unicode emoji
	* Method: `DELETE`
	* Authentication: required
	* Params: `emoji`: A single character unicode emoji
	* Response: JSON, the status.

	## `GET /api/v1/pleroma/statuses/:id/reactions`
	### Get an object of emoji to account mappings with accounts that reacted to the post
	* Method: `GET`
	* Authentication: optional
	* Params: None
	* Response: JSON, a list of emoji/account list tuples, sorted by emoji insertion date, in ascending order, e.g, the first emoji in the list is the oldest.
	* Example Response:
	```json
	[
	{"name": "😀", "count": 2, "me": true, "accounts": [{"id" => "xyz.."...}, {"id" => "zyx..."}]},
	{"name": "☕", "count": 1, "me": false, "accounts": [{"id" => "abc..."}]}
	]
	```

	## `GET /api/v1/pleroma/statuses/:id/reactions/:emoji`
	### Get an object of emoji to account mappings with accounts that reacted to the post for a specific emoji
	* Method: `GET`
	* Authentication: optional
	* Params: None
	* Response: JSON, a list of emoji/account list tuples
	* Example Response:
	```json
	[
	{"name": "😀", "count": 2, "me": true, "accounts": [{"id" => "xyz.."...}, {"id" => "zyx..."}]}
	]
	```
	diff --git a/docs/installation/alpine_linux_en.md b/docs/installation/alpine_linux_en.md
	index a5683f18c..d89c7f46f 100644
	--- a/docs/installation/alpine_linux_en.md
	+++ b/docs/installation/alpine_linux_en.md
	@@ -1,233 +1,242 @@
	# Installing on Alpine Linux
	## Installation

	This guide is a step-by-step installation guide for Alpine Linux. The instructions were verified against Alpine v3.10 standard image. You might miss additional dependencies if you use `netboot` instead.

	It assumes that you have administrative rights, either as root or a user with [sudo permissions](https://www.linode.com/docs/tools-reference/custom-kernels-distros/install-alpine-linux-on-your-linode/#configuration). If you want to run this guide with root, ignore the `sudo` at the beginning of the lines, unless it calls a user like `sudo -Hu pleroma`; in this case, use `su -l <username> -s $SHELL -c 'command'` instead.

	### Required packages

	* `postgresql`
	* `elixir`
	* `erlang`
	* `erlang-parsetools`
	* `erlang-xmerl`
	* `git`
	* Development Tools
	* `cmake`

	#### Optional packages used in this guide

	* `nginx` (preferred, example configs for other reverse proxies can be found in the repo)
	* `certbot` (or any other ACME client for Let’s Encrypt certificates)
	+* `ImageMagick`
	+* `ffmpeg`
	+* `exiftool`

	### Prepare the system

	* The community repository must be enabled in `/etc/apk/repositories`. Depending on which version and mirror you use this looks like `http://alpine.42.fr/v3.10/community`. If you autogenerated the mirror during installation:

	```shell
	awk 'NR==2' /etc/apk/repositories \| sed 's/main/community/' \| tee -a /etc/apk/repositories
	```

	-
	* Then update the system, if not already done:

	```shell
	sudo apk update
	sudo apk upgrade
	```

	* Install some tools, which are needed later:

	```shell
	sudo apk add git build-base cmake
	```

	### Install Elixir and Erlang

	* Install Erlang and Elixir:

	```shell
	sudo apk add erlang erlang-runtime-tools erlang-xmerl elixir
	```

	* Install `erlang-eldap` if you want to enable ldap authenticator

	```shell
	sudo apk add erlang-eldap
	```
	+
	### Install PostgreSQL

	* Install Postgresql server:

	```shell
	sudo apk add postgresql postgresql-contrib
	```

	* Initialize database:

	```shell
	sudo /etc/init.d/postgresql start
	```

	* Enable and start postgresql server:

	```shell
	sudo rc-update add postgresql
	```

	+### Install media / graphics packages (optional, see [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md))
	+
	+```shell
	+sudo apk add ffmpeg imagemagick exiftool
	+```
	+
	### Install PleromaBE

	* Add a new system user for the Pleroma service:

	```shell
	sudo addgroup pleroma
	sudo adduser -S -s /bin/false -h /opt/pleroma -H -G pleroma pleroma
	```

	Note: To execute a single command as the Pleroma system user, use `sudo -Hu pleroma command`. You can also switch to a shell by using `sudo -Hu pleroma $SHELL`. If you don’t have and want `sudo` on your system, you can use `su` as root user (UID 0) for a single command by using `su -l pleroma -s $SHELL -c 'command'` and `su -l pleroma -s $SHELL` for starting a shell.

	* Git clone the PleromaBE repository and make the Pleroma user the owner of the directory:

	```shell
	sudo mkdir -p /opt/pleroma
	sudo chown -R pleroma:pleroma /opt/pleroma
	sudo -Hu pleroma git clone -b stable https://git.pleroma.social/pleroma/pleroma /opt/pleroma
	```

	* Change to the new directory:

	```shell
	cd /opt/pleroma
	```

	* Install the dependencies for Pleroma and answer with `yes` if it asks you to install `Hex`:

	```shell
	sudo -Hu pleroma mix deps.get
	```

	* Generate the configuration: `sudo -Hu pleroma mix pleroma.instance gen`
	* Answer with `yes` if it asks you to install `rebar3`.
	* This may take some time, because parts of pleroma get compiled first.
	* After that it will ask you a few questions about your instance and generates a configuration file in `config/generated_config.exs`.

	* Check the configuration and if all looks right, rename it, so Pleroma will load it (`prod.secret.exs` for productive instance, `dev.secret.exs` for development instances):

	```shell
	mv config/{generated_config.exs,prod.secret.exs}
	```

	* The previous command creates also the file `config/setup_db.psql`, with which you can create the database:

	```shell
	sudo -Hu postgres psql -f config/setup_db.psql
	```

	* Now run the database migration:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix ecto.migrate
	```

	* Now you can start Pleroma already

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix phx.server
	```

	### Finalize installation

	If you want to open your newly installed instance to the world, you should run nginx or some other webserver/proxy in front of Pleroma and you should consider to create an OpenRC service file for Pleroma.

	#### Nginx

	* Install nginx, if not already done:

	```shell
	sudo apk add nginx
	```

	* Setup your SSL cert, using your method of choice or certbot. If using certbot, first install it:

	```shell
	sudo apk add certbot
	```

	and then set it up:

	```shell
	sudo mkdir -p /var/lib/letsencrypt/
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --standalone
	```

	If that doesn’t work, make sure, that nginx is not already running. If it still doesn’t work, try setting up nginx first (change ssl “on” to “off” and try again).

	* Copy the example nginx configuration to the nginx folder

	```shell
	sudo cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/conf.d/pleroma.conf
	```

	* Before starting nginx edit the configuration and change it to your needs. You must change change `server_name` and the paths to the certificates. You can use `nano` (install with `apk add nano` if missing).

	```
	server {
	server_name your.domain;
	listen 80;
	...
	}

	server {
	server_name your.domain;
	listen 443 ssl http2;
	...
	ssl_trusted_certificate /etc/letsencrypt/live/your.domain/chain.pem;
	ssl_certificate /etc/letsencrypt/live/your.domain/fullchain.pem;
	ssl_certificate_key /etc/letsencrypt/live/your.domain/privkey.pem;
	...
	}
	```

	* Enable and start nginx:

	```shell
	sudo rc-update add nginx
	sudo service nginx start
	```

	If you need to renew the certificate in the future, uncomment the relevant location block in the nginx config and run:

	```shell
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --webroot -w /var/lib/letsencrypt/
	```

	#### OpenRC service

	* Copy example service file:

	```shell
	sudo cp /opt/pleroma/installation/init.d/pleroma /etc/init.d/pleroma
	```

	* Make sure to start it during the boot

	```shell
	sudo rc-update add pleroma
	```

	#### Create your first user

	If your instance is up and running, you can create your first user with administrative rights with the following task:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```

	#### Further reading

	{! backend/installation/further_reading.include !}

	## 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/docs/installation/arch_linux_en.md b/docs/installation/arch_linux_en.md
	index 7fb69dd60..724b4660a 100644
	--- a/docs/installation/arch_linux_en.md
	+++ b/docs/installation/arch_linux_en.md
	@@ -1,208 +1,217 @@
	# Installing on Arch Linux
	## Installation

	This guide will assume that you have administrative rights, either as root or a user with [sudo permissions](https://wiki.archlinux.org/index.php/Sudo). If you want to run this guide with root, ignore the `sudo` at the beginning of the lines, unless it calls a user like `sudo -Hu pleroma`; in this case, use `su <username> -s $SHELL -c 'command'` instead.

	### Required packages

	* `postgresql`
	* `elixir`
	* `git`
	* `base-devel`
	* `cmake`

	#### Optional packages used in this guide

	* `nginx` (preferred, example configs for other reverse proxies can be found in the repo)
	* `certbot` (or any other ACME client for Let’s Encrypt certificates)
	+* `ImageMagick`
	+* `ffmpeg`
	+* `exiftool`

	### Prepare the system

	* First update the system, if not already done:

	```shell
	sudo pacman -Syu
	```

	* Install some of the above mentioned programs:

	```shell
	sudo pacman -S git base-devel elixir cmake
	```

	### Install PostgreSQL

	[Arch Wiki article](https://wiki.archlinux.org/index.php/PostgreSQL)

	* Install the `postgresql` package:

	```shell
	sudo pacman -S postgresql
	```

	* Initialize the database cluster:

	```shell
	sudo -iu postgres initdb -D /var/lib/postgres/data
	```

	* Start and enable the `postgresql.service`

	```shell
	sudo systemctl enable --now postgresql.service
	```

	+### Install media / graphics packages (optional, see [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md))
	+
	+```shell
	+sudo pacman -S ffmpeg imagemagick perl-image-exiftool
	+```
	+
	### Install PleromaBE

	* Add a new system user for the Pleroma service:

	```shell
	sudo useradd -r -s /bin/false -m -d /var/lib/pleroma -U pleroma
	```

	Note: To execute a single command as the Pleroma system user, use `sudo -Hu pleroma command`. You can also switch to a shell by using `sudo -Hu pleroma $SHELL`. If you don’t have and want `sudo` on your system, you can use `su` as root user (UID 0) for a single command by using `su -l pleroma -s $SHELL -c 'command'` and `su -l pleroma -s $SHELL` for starting a shell.

	* Git clone the PleromaBE repository and make the Pleroma user the owner of the directory:

	```shell
	sudo mkdir -p /opt/pleroma
	sudo chown -R pleroma:pleroma /opt/pleroma
	sudo -Hu pleroma git clone -b stable https://git.pleroma.social/pleroma/pleroma /opt/pleroma
	```

	* Change to the new directory:

	```shell
	cd /opt/pleroma
	```

	* Install the dependencies for Pleroma and answer with `yes` if it asks you to install `Hex`:

	```shell
	sudo -Hu pleroma mix deps.get
	```

	* Generate the configuration: `sudo -Hu pleroma mix pleroma.instance gen`
	* Answer with `yes` if it asks you to install `rebar3`.
	* This may take some time, because parts of pleroma get compiled first.
	* After that it will ask you a few questions about your instance and generates a configuration file in `config/generated_config.exs`.

	* Check the configuration and if all looks right, rename it, so Pleroma will load it (`prod.secret.exs` for productive instance, `dev.secret.exs` for development instances):

	```shell
	mv config/{generated_config.exs,prod.secret.exs}
	```

	* The previous command creates also the file `config/setup_db.psql`, with which you can create the database:

	```shell
	sudo -Hu postgres psql -f config/setup_db.psql
	```

	* Now run the database migration:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix ecto.migrate
	```

	* Now you can start Pleroma already

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix phx.server
	```

	### Finalize installation

	If you want to open your newly installed instance to the world, you should run nginx or some other webserver/proxy in front of Pleroma and you should consider to create a systemd service file for Pleroma.

	#### Nginx

	* Install nginx, if not already done:

	```shell
	sudo pacman -S nginx
	```

	* Create directories for available and enabled sites:

	```shell
	sudo mkdir -p /etc/nginx/sites-{available,enabled}
	```

	* Append the following line at the end of the `http` block in `/etc/nginx/nginx.conf`:

	```Nginx
	include sites-enabled/*;
	```

	* Setup your SSL cert, using your method of choice or certbot. If using certbot, first install it:

	```shell
	sudo pacman -S certbot certbot-nginx
	```

	and then set it up:

	```shell
	sudo mkdir -p /var/lib/letsencrypt/
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --standalone
	```

	If that doesn’t work, make sure, that nginx is not already running. If it still doesn’t work, try setting up nginx first (change ssl “on” to “off” and try again).

	---

	* Copy the example nginx configuration and activate it:

	```shell
	sudo cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/pleroma.nginx
	sudo ln -s /etc/nginx/sites-available/pleroma.nginx /etc/nginx/sites-enabled/pleroma.nginx
	```

	* Before starting nginx edit the configuration and change it to your needs (e.g. change servername, change cert paths)
	* Enable and start nginx:

	```shell
	sudo systemctl enable --now nginx.service
	```

	If you need to renew the certificate in the future, uncomment the relevant location block in the nginx config and run:

	```shell
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --webroot -w /var/lib/letsencrypt/
	```

	#### Other webserver/proxies

	You can find example configurations for them in `/opt/pleroma/installation/`.

	#### Systemd service

	* Copy example service file

	```shell
	sudo cp /opt/pleroma/installation/pleroma.service /etc/systemd/system/pleroma.service
	```

	* Edit the service file and make sure that all paths fit your installation
	* Enable and start `pleroma.service`:

	```shell
	sudo systemctl enable --now pleroma.service
	```

	#### Create your first user

	If your instance is up and running, you can create your first user with administrative rights with the following task:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```

	#### Further reading

	{! backend/installation/further_reading.include !}

	## 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/docs/installation/debian_based_en.md b/docs/installation/debian_based_en.md
	index 60c2f47e5..eac499a29 100644
	--- a/docs/installation/debian_based_en.md
	+++ b/docs/installation/debian_based_en.md
	@@ -1,194 +1,203 @@
	# Installing on Debian Based Distributions
	## Installation

	This guide will assume you are on Debian Stretch. This guide should also work with Ubuntu 16.04 and 18.04. It also assumes that you have administrative rights, either as root or a user with [sudo permissions](https://www.digitalocean.com/community/tutorials/how-to-add-delete-and-grant-sudo-privileges-to-users-on-a-debian-vps). If you want to run this guide with root, ignore the `sudo` at the beginning of the lines, unless it calls a user like `sudo -Hu pleroma`; in this case, use `su <username> -s $SHELL -c 'command'` instead.

	### Required packages

	* `postgresql` (9.6+, Ubuntu 16.04 comes with 9.5, you can get a newer version from [here](https://www.postgresql.org/download/linux/ubuntu/))
	* `postgresql-contrib` (9.6+, same situtation as above)
	* `elixir` (1.8+, Follow the guide to install from the Erlang Solutions repo or use [asdf](https://github.com/asdf-vm/asdf) as the pleroma user)
	* `erlang-dev`
	* `erlang-nox`
	* `git`
	* `build-essential`
	* `cmake`

	#### Optional packages used in this guide

	* `nginx` (preferred, example configs for other reverse proxies can be found in the repo)
	* `certbot` (or any other ACME client for Let’s Encrypt certificates)
	+* `ImageMagick`
	+* `ffmpeg`
	+* `exiftool`

	### Prepare the system

	* First update the system, if not already done:

	```shell
	sudo apt update
	sudo apt full-upgrade
	```

	* Install some of the above mentioned programs:

	```shell
	sudo apt install git build-essential postgresql postgresql-contrib cmake
	```

	### Install Elixir and Erlang

	* Download and add the Erlang repository:

	```shell
	wget -P /tmp/ https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
	sudo dpkg -i /tmp/erlang-solutions_2.0_all.deb
	```

	* Install Elixir and Erlang:

	```shell
	sudo apt update
	sudo apt install elixir erlang-dev erlang-nox
	```

	+### Optional packages: [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md)
	+
	+```shell
	+sudo apt install imagemagick ffmpeg libimage-exiftool-perl
	+```
	+
	### Install PleromaBE

	* Add a new system user for the Pleroma service:

	```shell
	sudo useradd -r -s /bin/false -m -d /var/lib/pleroma -U pleroma
	```

	Note: To execute a single command as the Pleroma system user, use `sudo -Hu pleroma command`. You can also switch to a shell by using `sudo -Hu pleroma $SHELL`. If you don’t have and want `sudo` on your system, you can use `su` as root user (UID 0) for a single command by using `su -l pleroma -s $SHELL -c 'command'` and `su -l pleroma -s $SHELL` for starting a shell.

	* Git clone the PleromaBE repository and make the Pleroma user the owner of the directory:

	```shell
	sudo mkdir -p /opt/pleroma
	sudo chown -R pleroma:pleroma /opt/pleroma
	sudo -Hu pleroma git clone -b stable https://git.pleroma.social/pleroma/pleroma /opt/pleroma
	```

	* Change to the new directory:

	```shell
	cd /opt/pleroma
	```

	* Install the dependencies for Pleroma and answer with `yes` if it asks you to install `Hex`:

	```shell
	sudo -Hu pleroma mix deps.get
	```

	* Generate the configuration: `sudo -Hu pleroma mix pleroma.instance gen`
	* Answer with `yes` if it asks you to install `rebar3`.
	* This may take some time, because parts of pleroma get compiled first.
	* After that it will ask you a few questions about your instance and generates a configuration file in `config/generated_config.exs`.

	* Check the configuration and if all looks right, rename it, so Pleroma will load it (`prod.secret.exs` for productive instance, `dev.secret.exs` for development instances):

	```shell
	mv config/{generated_config.exs,prod.secret.exs}
	```

	* The previous command creates also the file `config/setup_db.psql`, with which you can create the database:

	```shell
	sudo -Hu postgres psql -f config/setup_db.psql
	```

	* Now run the database migration:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix ecto.migrate
	```

	* Now you can start Pleroma already

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix phx.server
	```

	### Finalize installation

	If you want to open your newly installed instance to the world, you should run nginx or some other webserver/proxy in front of Pleroma and you should consider to create a systemd service file for Pleroma.

	#### Nginx

	* Install nginx, if not already done:

	```shell
	sudo apt install nginx
	```

	* Setup your SSL cert, using your method of choice or certbot. If using certbot, first install it:

	```shell
	sudo apt install certbot
	```

	and then set it up:

	```shell
	sudo mkdir -p /var/lib/letsencrypt/
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --standalone
	```

	If that doesn’t work, make sure, that nginx is not already running. If it still doesn’t work, try setting up nginx first (change ssl “on” to “off” and try again).

	---

	* Copy the example nginx configuration and activate it:

	```shell
	sudo cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/pleroma.nginx
	sudo ln -s /etc/nginx/sites-available/pleroma.nginx /etc/nginx/sites-enabled/pleroma.nginx
	```

	* Before starting nginx edit the configuration and change it to your needs (e.g. change servername, change cert paths)
	* Enable and start nginx:

	```shell
	sudo systemctl enable --now nginx.service
	```

	If you need to renew the certificate in the future, uncomment the relevant location block in the nginx config and run:

	```shell
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --webroot -w /var/lib/letsencrypt/
	```

	#### Other webserver/proxies

	You can find example configurations for them in `/opt/pleroma/installation/`.

	#### Systemd service

	* Copy example service file

	```shell
	sudo cp /opt/pleroma/installation/pleroma.service /etc/systemd/system/pleroma.service
	```

	* Edit the service file and make sure that all paths fit your installation
	* Enable and start `pleroma.service`:

	```shell
	sudo systemctl enable --now pleroma.service
	```

	#### Create your first user

	If your instance is up and running, you can create your first user with administrative rights with the following task:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```

	#### Further reading

	{! backend/installation/further_reading.include !}

	## 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/docs/installation/debian_based_jp.md b/docs/installation/debian_based_jp.md
	index c2dd840d3..764afbe1a 100644
	--- a/docs/installation/debian_based_jp.md
	+++ b/docs/installation/debian_based_jp.md
	@@ -1,186 +1,194 @@
	# Pleromaの入れ方
	## 日本語訳について

	この記事は [Installing on Debian based distributions](Installing on Debian based distributions) の日本語訳です。何かがおかしいと思ったら、原文を見てください。

	## インストール

	このガイドはDebian Stretchを利用することを想定しています。Ubuntu 16.04や18.04でもおそらく動作します。また、ユーザはrootもしくはsudoにより管理者権限を持っていることを前提とします。もし、以下の操作をrootユーザで行う場合は、 `sudo` を無視してください。ただし、`sudo -Hu pleroma` のようにユーザを指定している場合には `su <username> -s $SHELL -c 'command'` を代わりに使ってください。

	### 必要なソフトウェア

	- PostgreSQL 9.6以上 (Ubuntu16.04では9.5しか提供されていないので，[](https://www.postgresql.org/download/linux/ubuntu/)こちらから新しいバージョンを入手してください)
	- `postgresql-contrib` 9.6以上 (同上)
	- Elixir 1.8 以上 ([Debianのリポジトリからインストールしないこと！！！ここからインストールすること！](https://elixir-lang.org/install.html#unix-and-unix-like)。または [asdf](https://github.com/asdf-vm/asdf) をpleromaユーザーでインストールしてください)
	- `erlang-dev`
	- `erlang-nox`
	- `git`
	- `build-essential`
	- `cmake`

	#### このガイドで利用している追加パッケージ

	- `nginx` (おすすめです。他のリバースプロキシを使う場合は、参考となる設定をこのリポジトリから探してください)
	- `certbot` (または何らかのLet's Encrypt向けACMEクライアント)
	+- `ImageMagick`
	+- `ffmpeg`
	+- `exiftool`

	### システムを準備する

	* まずシステムをアップデートしてください。
	```
	sudo apt update
	sudo apt full-upgrade
	```

	* 上記に挙げたパッケージをインストールしておきます。
	```
	-sudo apt install git build-essential postgresql postgresql-contrib cmake
	+sudo apt install git build-essential postgresql postgresql-contrib cmake ffmpeg imagemagick
	```

	-
	### ElixirとErlangをインストールします

	* Erlangのリポジトリをダウンロードおよびインストールします。
	```
	wget -P /tmp/ https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
	sudo dpkg -i /tmp/erlang-solutions_2.0_all.deb
	```

	* ElixirとErlangをインストールします、
	```
	sudo apt update
	sudo apt install elixir erlang-dev erlang-nox
	```

	+### オプションパッケージ: [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md)
	+
	+```shell
	+sudo apt install imagemagick ffmpeg libimage-exiftool-perl
	+```
	+
	### Pleroma BE (バックエンド) をインストールします

	* Pleroma用に新しいユーザーを作ります。

	```
	sudo useradd -r -s /bin/false -m -d /var/lib/pleroma -U pleroma
	```

	注意: Pleromaユーザとして単発のコマンドを実行したい場合はは、`sudo -Hu pleroma command` を使ってください。シェルを使いたい場合は `sudo -Hu pleroma $SHELL`です。もし `sudo` を使わない場合は、rootユーザで `su -l pleroma -s $SHELL -c 'command'` とすることでコマンドを、`su -l pleroma -s $SHELL` とすることでシェルを開始できます。

	* Gitリポジトリをクローンします。
	```
	sudo mkdir -p /opt/pleroma
	sudo chown -R pleroma:pleroma /opt/pleroma
	sudo -Hu pleroma git clone -b stable https://git.pleroma.social/pleroma/pleroma /opt/pleroma
	```

	* 新しいディレクトリに移動します。
	```
	cd /opt/pleroma
	```

	* Pleromaが依存するパッケージをインストールします。Hexをインストールしてもよいか聞かれたら、yesを入力してください。
	```
	sudo -Hu pleroma mix deps.get
	```

	* コンフィギュレーションを生成します。
	```
	sudo -Hu pleroma mix pleroma.instance gen
	```
	* rebar3をインストールしてもよいか聞かれたら、yesを入力してください。
	* このときにpleromaの一部がコンパイルされるため、この処理には時間がかかります。
	* あなたのインスタンスについて、いくつかの質問されます。この質問により `config/generated_config.exs` という設定ファイルが生成されます。


	* コンフィギュレーションを確認して、もし問題なければ、ファイル名を変更してください。
	```
	mv config/{generated_config.exs,prod.secret.exs}
	```

	* 先程のコマンドで、すでに `config/setup_db.psql` というファイルが作られています。このファイルをもとに、データベースを作成します。
	```
	sudo -Hu pleroma mix pleroma.instance gen
	```

	* そして、データベースのマイグレーションを実行します。
	```
	sudo -Hu pleroma MIX_ENV=prod mix ecto.migrate
	```

	* これでPleromaを起動できるようになりました。
	```
	sudo -Hu pleroma MIX_ENV=prod mix phx.server
	```

	### インストールの最終段階

	あなたの新しいインスタンスを世界に向けて公開するには、nginx等のWebサーバやプロキシサーバをPleromaの前段に使用する必要があります。また、Pleroma のためにシステムサービスファイルを作成する必要があります。

	#### Nginx

	* まだインストールしていないなら、nginxをインストールします。
	```
	sudo apt install nginx
	```

	* SSLをセットアップします。他の方法でもよいですが、ここではcertbotを説明します。
	certbotを使うならば、まずそれをインストールします。
	```
	sudo apt install certbot
	```
	そしてセットアップします。
	```
	sudo mkdir -p /var/lib/letsencrypt/
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --standalone
	```
	もしうまくいかないときは、nginxが正しく動いていない可能性があります。先にnginxを設定してください。ssl "on" を "off" に変えてから再試行してください。

	---

	* nginxの設定ファイルサンプルをnginxフォルダーにコピーします。
	```
	sudo cp /opt/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/pleroma.nginx
	sudo ln -s /etc/nginx/sites-available/pleroma.nginx /etc/nginx/sites-enabled/pleroma.nginx
	```

	* nginxを起動する前に、設定ファイルを編集してください。例えば、サーバー名、証明書のパスなどを変更する必要があります。
	* nginxを再起動します。
	```
	sudo systemctl enable --now nginx.service
	```

	もし証明書を更新する必要が出てきた場合には、nginxの関連するlocationブロックのコメントアウトを外し、以下のコマンドを動かします。

	```
	sudo certbot certonly --email <your@emailaddress> -d <yourdomain> --webroot -w /var/lib/letsencrypt/
	```

	#### 他のWebサーバやプロキシ
	これに関してはサンプルが `/opt/pleroma/installation/` にあるので、探してみてください。

	#### Systemd サービス

	* サービスファイルのサンプルをコピーします。
	```
	sudo cp /opt/pleroma/installation/pleroma.service /etc/systemd/system/pleroma.service
	```

	* サービスファイルを変更します。すべてのパスが正しいことを確認してください
	* サービスを有効化し `pleroma.service` を開始してください
	```
	sudo systemctl enable --now pleroma.service
	```

	#### 初期ユーザの作成

	新たにインスタンスを作成したら、以下のコマンドにより管理者権限を持った初期ユーザを作成できます。

	```
	sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```

	#### その他の設定とカスタマイズ

	{! backend/installation/further_reading.include !}

	## 質問ある？

	インストールについて質問がある、もしくは、うまくいかないときは、以下のところで質問できます。

	* [#pleroma:matrix.org](https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org)
	* Freenode の #pleroma IRCチャンネル
	diff --git a/docs/installation/freebsd_en.md b/docs/installation/freebsd_en.md
	index ca2575d9b..fdcb06c53 100644
	--- a/docs/installation/freebsd_en.md
	+++ b/docs/installation/freebsd_en.md
	@@ -1,210 +1,216 @@
	# Installing on FreeBSD

	This document was written for FreeBSD 12.1, but should be work on future releases.

	## Required software

	This assumes the target system has `pkg(8)`.

	```
	# pkg install elixir postgresql12-server postgresql12-client postgresql12-contrib git-lite sudo nginx gmake acme.sh cmake
	```

	Copy the rc.d scripts to the right directory:

	Setup the required services to automatically start at boot, using `sysrc(8)`.

	```
	# sysrc nginx_enable=YES
	# sysrc postgresql_enable=YES
	```

	## Initialize postgres

	```
	# service postgresql initdb
	# service postgresql start
	```

	+### Install media / graphics packages (optional, see [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md))
	+
	+```shell
	+# pkg install imagemagick ffmpeg p5-Image-ExifTool
	+```
	+
	## Configuring Pleroma

	Create a user for Pleroma:

	```
	# pw add user pleroma -m
	# echo 'export LC_ALL="en_US.UTF-8"' >> /home/pleroma/.profile
	# su -l pleroma
	```

	Clone the repository:

	```
	$ cd $HOME # Should be the same as /home/pleroma
	$ git clone -b stable https://git.pleroma.social/pleroma/pleroma.git
	```

	Configure Pleroma. Note that you need a domain name at this point:

	```
	$ cd /home/pleroma/pleroma
	$ mix deps.get # Enter "y" when asked to install Hex
	$ mix pleroma.instance gen # You will be asked a few questions here.
	$ cp config/generated_config.exs config/prod.secret.exs
	```

	Since Postgres is configured, we can now initialize the database. There should
	now be a file in `config/setup_db.psql` that makes this easier. Edit it, and
	change the password to a password of your choice. Make sure it is secure, since
	it'll be protecting your database. As root, you can now initialize the database:

	```
	# cd /home/pleroma/pleroma
	# sudo -Hu postgres -g postgres psql -f config/setup_db.psql
	```

	Postgres allows connections from all users without a password by default. To
	fix this, edit `/var/db/postgres/data12/pg_hba.conf`. Change every `trust` to
	`password`.

	Once this is done, restart Postgres with:
	```
	# service postgresql restart
	```

	Run the database migrations.

	Back as the pleroma user, run the following to implement any database migrations.

	```
	# su -l pleroma
	$ cd /home/pleroma/pleroma
	$ MIX_ENV=prod mix ecto.migrate
	```

	You will need to do this whenever you update with `git pull`:

	## Configuring acme.sh

	We'll be using acme.sh in Stateless Mode for TLS certificate renewal.

	First, as root, allow the user `acme` to have access to the acme log file, as follows:

	```
	# touch /var/log/acme.sh.log
	# chown acme:acme /var/log/acme.sh.log
	# chmod 600 /var/log/acme.sh.log
	```

	Next, obtain your account fingerprint:

	```
	# sudo -Hu acme -g acme acme.sh --register-account
	```

	You need to add the following to your nginx configuration for the server
	running on port 80:

	```
	location ~ ^/\.well-known/acme-challenge/([-_a-zA-Z0-9]+)$ {
	default_type text/plain;
	return 200 "$1.6fXAG9VyG0IahirPEU2ZerUtItW2DHzDzD9wZaEKpqd";
	}
	```

	Replace the string after after `$1.` with your fingerprint.

	Start nginx:

	```
	# service nginx start
	```

	It should now be possible to issue a cert (replace `example.com`
	with your domain name):

	```
	# sudo -Hu acme -g acme acme.sh --issue -d example.com --stateless
	```

	Let's add auto-renewal to `/etc/crontab`
	(replace `example.com` with your domain):

	```
	/usr/local/bin/sudo -Hu acme -g acme /usr/local/sbin/acme.sh -r -d example.com --stateless
	```

	### Configuring nginx

	FreeBSD's default nginx configuration does not contain an include directive, which is
	typically used for multiple sites. Therefore, you will need to first create the required
	directory as follows:


	```
	# mkdir -p /usr/local/etc/nginx/sites-available
	```

	Next, add an `include` directive to `/usr/local/etc/nginx/nginx.conf`, within the `http {}`
	block, as follows:


	```
	http {
	...
	include /usr/local/etc/nginx/sites-available/*;
	}
	```

	As root, copy `/home/pleroma/pleroma/installation/pleroma.nginx` to
	`/usr/local/etc/nginx/sites-available/pleroma.nginx`.

	Edit the defaults of `/usr/local/etc/nginx/sites-available/pleroma.nginx`:

	* Change `ssl_trusted_certificate` to `/var/db/acme/certs/example.tld/example.tld.cer`.
	* Change `ssl_certificate` to `/var/db/acme/certs/example.tld/fullchain.cer`.
	* Change `ssl_certificate_key` to `/var/db/acme/certs/example.tld/example.tld.key`.
	* Change all references of `example.tld` to your instance's domain name.

	## Creating a startup script for Pleroma

	Pleroma will need to compile when it initially starts, which typically takes a longer
	period of time. Therefore, it is good practice to initially run pleroma from the
	command-line before utilizing the rc.d script. That is done as follows:

	```
	# su -l pleroma
	$ cd $HOME/pleroma
	$ MIX_ENV=prod mix phx.server
	```

	Copy the startup script to the correct location and make sure it's executable:

	```
	# cp /home/pleroma/pleroma/installation/freebsd/rc.d/pleroma /usr/local/etc/rc.d/pleroma
	# chmod +x /usr/local/etc/rc.d/pleroma
	```

	Update the `/etc/rc.conf` and start pleroma with the following commands:

	```
	# sysrc pleroma_enable=YES
	# service pleroma start
	```

	#### Create your first user

	If your instance is up and running, you can create your first user with administrative rights with the following task:

	```shell
	sudo -Hu pleroma MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```
	## Conclusion

	Restart nginx with `# service nginx restart` and you should be up and running.

	Make sure your time is in sync, or other instances will receive your posts with
	incorrect timestamps. You should have ntpd running.

	## 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/docs/installation/gentoo_en.md b/docs/installation/gentoo_en.md
	index 5a676380c..638fc4e47 100644
	--- a/docs/installation/gentoo_en.md
	+++ b/docs/installation/gentoo_en.md
	@@ -1,291 +1,300 @@
	# Installing on Gentoo GNU/Linux
	## Installation

	This guide will assume that you have administrative rights, either as root or a user with [sudo permissions](https://wiki.gentoo.org/wiki/Sudo). Lines that begin with `#` indicate that they should be run as the superuser. Lines using `$` should be run as the indicated user, e.g. `pleroma$` should be run as the `pleroma` user.

	### Configuring your hostname (optional)

	If you would like your prompt to permanently include your host/domain, change `/etc/conf.d/hostname` to your hostname. You can reboot or use the `hostname` command to make immediate changes.

	### Your make.conf, package.use, and USE flags

	The only specific USE flag you should need is the `uuid` flag for `dev-db/postgresql`. Add the following line to any new file in `/etc/portage/package.use`. If you would like a suggested name for the file, either `postgresql` or `pleroma` would do fine, depending on how you like to arrange your package.use flags.

	```text
	dev-db/postgresql uuid
	```

	You could opt to add `USE="uuid"` to `/etc/portage/make.conf` if you'd rather set this as a global USE flags, but this flags does unrelated things in other packages, so keep that in mind if you elect to do so.

	Double check your compiler flags in `/etc/portage/make.conf`. If you require any special compilation flags or would like to set up remote builds, now is the time to do so. Be sure that your CFLAGS and MAKEOPTS make sense for the platform you are using. It is not recommended to use above `-O2` or risky optimization flags for a production server.

	### Installing a cron daemon

	Gentoo quite pointedly does not come with a cron daemon installed, and as such it is recommended you install one to automate certbot renewals and to allow other system administration tasks to be run automatically. Gentoo has [a whole wide world of cron options](https://wiki.gentoo.org/wiki/Cron) but if you just want A Cron That Works, `emerge --ask virtual/cron` will install the default cron implementation (probably cronie) which will work just fine. For the purpouses of this guide, we will be doing just that.

	### Required ebuilds

	* `dev-db/postgresql`
	* `dev-lang/elixir`
	* `dev-vcs/git`
	* `dev-util/cmake`

	#### Optional ebuilds used in this guide

	* `www-servers/nginx` (preferred, example configs for other reverse proxies can be found in the repo)
	* `app-crypt/certbot` (or any other ACME client for Let’s Encrypt certificates)
	* `app-crypt/certbot-nginx` (nginx certbot plugin that allows use of the all-powerful `--nginx` flag on certbot)
	+* `media-gfx/imagemagick`
	+* `media-video/ffmpeg`
	+* `media-libs/exiftool`

	### Prepare the system

	* First ensure that you have the latest copy of the portage ebuilds if you have not synced them yet:

	```shell
	# emaint sync -a
	```

	* Emerge all required the required and suggested software in one go:

	```shell
	# emerge --ask dev-db/postgresql dev-lang/elixir dev-vcs/git www-servers/nginx app-crypt/certbot app-crypt/certbot-nginx dev-util/cmake
	```

	If you would not like to install the optional packages, remove them from this line.

	If you're running this from a low-powered virtual machine, it should work though it will take some time. There were no issues on a VPS with a single core and 1GB of RAM; if you are using an even more limited device and run into issues, you can try creating a swapfile or use a more powerful machine running Gentoo to [cross build](https://wiki.gentoo.org/wiki/Cross_build_environment). If you have a wait ahead of you, now would be a good time to take a break, strech a bit, refresh your beverage of choice and/or get a snack, and reply to Arch users' posts with "I use Gentoo btw" as we do.

	### Install PostgreSQL

	[Gentoo Wiki article](https://wiki.gentoo.org/wiki/PostgreSQL) as well as [PostgreSQL QuickStart](https://wiki.gentoo.org/wiki/PostgreSQL/QuickStart) might be worth a quick glance, as the way Gentoo handles postgres is slightly unusual, with built in capability to have two different databases running for testing and live or whatever other purpouse. While it is still straightforward to install, it does mean that the version numbers used in this guide might change for future updates, so keep an eye out for the output you get from `emerge` to ensure you are using the correct ones.

	* Install postgresql if you have not done so already:

	```shell
	# emerge --ask dev-db/postgresql
	```

	Ensure that `/etc/conf.d/postgresql-11` has the encoding you want (it defaults to UTF8 which is probably what you want) and make any adjustments to the data directory if you find it necessary. Be sure to adjust the number at the end depending on what version of postgres you actually installed.

	* Initialize the database cluster

	The output from emerging postgresql should give you a command for initializing the postgres database. The default slot should be indicated in this command, ensure that it matches the command below.

	```shell
	# emerge --config dev-db/postgresql:11
	```

	* Start postgres and enable the system service

	```shell
	# /etc/init.d/postgresql-11 start
	# rc-update add postgresql-11 default
	```

	### A note on licenses, the AGPL, and deployment procedures

	If you do not plan to make any modifications to your Pleroma instance, cloning directly from the main repo will get you what you need. However, if you plan on doing any contributions to upstream development, making changes or modifications to your instance, making custom themes, or want to play around--and let's be honest here, if you're using Gentoo that is most likely you--you will save yourself a lot of headache later if you take the time right now to fork the Pleroma repo and use that in the following section.

	Not only does this make it much easier to deploy changes you make, as you can commit and pull from upstream and all that good stuff from the comfort of your local machine then simply `git pull` on your instance server when you're ready to deploy, it also ensures you are compliant with the Affero General Public Licence that Pleroma is licenced under, which stipulates that all network services provided with modified AGPL code must publish their changes on a publicly available internet service and for free. It also makes it much easier to ask for help from and provide help to your fellow Pleroma admins if your public repo always reflects what you are running because it is part of your deployment procedure.

	+### Install media / graphics packages (optional, see [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md))
	+
	+```shell
	+# emerge --ask media-video/ffmpeg media-gfx/imagemagick media-libs/exiftool
	+```
	+
	### Install PleromaBE

	* Add a new system user for the Pleroma service and set up default directories:

	Remove `,wheel` if you do not want this user to be able to use `sudo`, however note that being able to `sudo` as the `pleroma` user will make finishing the insallation and common maintenence tasks somewhat easier:

	```shell
	# useradd -m -G users,wheel -s /bin/bash pleroma
	```

	Optional: If you are using sudo, review your sudo setup to ensure it works for you. The `/etc/sudoers` file has a lot of options and examples to help you, and [the Gentoo sudo guide](https://wiki.gentoo.org/wiki/Sudo) has more information. Finishing this installation will be somewhat easier if you have a way to sudo from the `pleroma` user, but it might be best to not allow that user to sudo during normal operation, and as such there will be a reminder at the end of this guide to double check if you would like to lock down the `pleroma` user after initial setup.

	Note: To execute a single command as the Pleroma system user, use `sudo -Hu pleroma command`. You can also switch to a shell by using `sudo -Hu pleroma $SHELL`. If you don't have or want `sudo` or would like to use the system as the `pleroma` user for instance maintenance tasks, you can simply use `su - pleroma` to switch to the `pleroma` user.

	* Git clone the PleromaBE repository and make the Pleroma user the owner of the directory:

	It is highly recommended you use your own fork for the `https://path/to/repo` part below, however if you foolishly decide to forego using your own fork, the primary repo `https://git.pleroma.social/pleroma/pleroma` will work here.

	```shell
	pleroma$ cd ~
	pleroma$ git clone -b stable https://path/to/repo
	```

	* Change to the new directory:

	```shell
	pleroma$ cd ~/pleroma
	```

	* Install the dependencies for Pleroma and answer with `yes` if it asks you to install `Hex`:

	```shell
	pleroma$ mix deps.get
	```

	* Generate the configuration:

	```shell
	pleroma$ mix pleroma.instance gen
	```

	* Answer with `yes` if it asks you to install `rebar3`.

	* This part precompiles some parts of Pleroma, so it might take a few moments

	* After that it will ask you a few questions about your instance and generates a configuration file in `config/generated_config.exs`.

	* Spend some time with `generated_config.exs` to ensure that everything is in order. If you plan on using an S3-compatible service to store your local media, that can be done here. You will likely mostly be using `prod.secret.exs` for a production instance, however if you would like to set up a development environment, make a copy to `dev.secret.exs` and adjust settings as needed as well.

	```shell
	pleroma$ mv config/generated_config.exs config/prod.secret.exs
	```

	* The previous command creates also the file `config/setup_db.psql`, with which you can create the database. Ensure that it is using the correct database name on the `CREATE DATABASE` and the `\c` lines, then run the postgres script:

	```shell
	pleroma$ sudo -Hu postgres psql -f config/setup_db.psql
	```

	* Now run the database migration:

	```shell
	pleroma$ MIX_ENV=prod mix ecto.migrate
	```

	* Now you can start Pleroma already

	```shell
	pleroma$ MIX_ENV=prod mix phx.server
	```

	It probably won't work over the public internet quite yet, however, as we still need to set up a web servere to proxy to the pleroma application, as well as configure SSL.

	### Finalize installation

	Assuming you want to open your newly installed federated social network to, well, the federation, you should run nginx or some other webserver/proxy in front of Pleroma. It is also a good idea to set up Pleroma to run as a system service.

	#### Nginx

	* Install nginx, if not already done:

	```shell
	# emerge --ask www-servers/nginx
	```

	* Create directories for available and enabled sites:

	```shell
	# mkdir -p /etc/nginx/sites-{available,enabled}
	```

	* Append the following line at the end of the `http` block in `/etc/nginx/nginx.conf`:

	```Nginx
	include sites-enabled/*;
	```

	* Setup your SSL cert, using your method of choice or certbot. If using certbot, install it if you haven't already:

	```shell
	# emerge --ask app-crypt/certbot app-crypt/certbot-nginx
	```

	and then set it up:

	```shell
	# mkdir -p /var/lib/letsencrypt/
	# certbot certonly --email <your@emailaddress> -d <yourdomain> --standalone
	```

	If that doesn't work the first time, add `--dry-run` to further attempts to avoid being ratelimited as you identify the issue, and do not remove it until the dry run succeeds. If that doesn’t work, make sure, that nginx is not already running. If it still doesn’t work, try setting up nginx first (change ssl “on” to “off” and try again). Often the answer to issues with certbot is to use the `--nginx` flag once you have nginx up and running.

	If you are using any additional subdomains, such as for a media proxy, you can re-run the same command with the subdomain in question. When it comes time to renew later, you will not need to run multiple times for each domain, one renew will handle it.

	---

	* Copy the example nginx configuration and activate it:

	```shell
	# cp /home/pleroma/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/
	# ln -s /etc/nginx/sites-available/pleroma.nginx /etc/nginx/sites-enabled/pleroma.nginx
	```

	* Take some time to ensure that your nginx config is correct

	Replace all instances of `example.tld` with your instance's public URL. If for whatever reason you made changes to the port that your pleroma app runs on, be sure that is reflected in your configuration.

	Pay special attention to the line that begins with `ssl_ecdh_curve`. It is stongly advised to comment that line out so that OpenSSL will use its full capabilities, and it is also possible you are running OpenSSL 1.0.2 necessitating that you do this.

	* Enable and start nginx:

	```shell
	# rc-update add nginx default
	# /etc/init.d/nginx start
	```

	If you are using certbot, it is HIGHLY recommend you set up a cron job that renews your certificate, and that you install the suggested `certbot-nginx` plugin. If you don't do these things, you only have yourself to blame when your instance breaks suddenly because you forgot about it.

	First, ensure that the command you will be installing into your crontab works.

	```shell
	# /usr/bin/certbot renew --nginx
	```

	Assuming not much time has passed since you got certbot working a few steps ago, you should get a message for all domains you installed certificates for saying `Cert not yet due for renewal`.

	Now, run crontab as a superuser with `crontab -e` or `sudo crontab -e` as appropriate, and add the following line to your cron:

	```cron
	0 0 1 * * /usr/bin/certbot renew --nginx
	```

	This will run certbot on the first of the month at midnight. If you'd rather run more frequently, it's not a bad idea, feel free to go for it.

	#### Other webserver/proxies

	If you would like to use other webservers or proxies, there are example configurations for some popular alternatives in `/home/pleroma/pleroma/installation/`. You can, of course, check out [the Gentoo wiki](https://wiki.gentoo.org) for more information on installing and configuring said alternatives.

	#### Create the uploads folder

	Even if you are using S3, Pleroma needs someplace to store media posted on your instance. If you are using the `/home/pleroma/pleroma` root folder suggested by this guide, simply:

	```shell
	pleroma$ mkdir -p ~/pleroma/uploads
	```

	#### init.d service

	* Copy example service file

	```shell
	# cp /home/pleroma/pleroma/installation/init.d/pleroma /etc/init.d/
	```

	* Be sure to take a look at this service file and make sure that all paths fit your installation

	* Enable and start `pleroma`:

	```shell
	# rc-update add pleroma default
	# /etc/init.d/pleroma start
	```

	#### Create your first user

	If your instance is up and running, you can create your first user with administrative rights with the following task:

	```shell
	pleroma$ MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```

	#### Privilege cleanup

	If you opted to allow sudo for the `pleroma` user but would like to remove the ability for greater security, now might be a good time to edit `/etc/sudoers` and/or change the groups the `pleroma` user belongs to. Be sure to restart the pleroma service afterwards to ensure it picks up on the changes.

	#### Further reading

	{! backend/installation/further_reading.include !}

	## 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/docs/installation/netbsd_en.md b/docs/installation/netbsd_en.md
	index 6ad0de2f6..d5fa04fdf 100644
	--- a/docs/installation/netbsd_en.md
	+++ b/docs/installation/netbsd_en.md
	@@ -1,207 +1,211 @@
	# Installing on NetBSD

	## Required software

	pkgin should have been installed by the NetBSD installer if you selected
	the right options. If it isn't installed, install it using pkg_add.

	Note that `postgresql11-contrib` is needed for the Postgres extensions
	Pleroma uses.

	The `mksh` shell is needed to run the Elixir `mix` script.

	-`# pkgin install acmesh elixir git-base git-docs mksh nginx postgresql11-server postgresql11-client postgresql11-contrib sudo`
	+`# pkgin install acmesh elixir git-base git-docs mksh nginx postgresql11-server postgresql11-client postgresql11-contrib sudo ffmpeg4 ImageMagick`

	You can also build these packages using pkgsrc:
	```
	databases/postgresql11-contrib
	databases/postgresql11-client
	databases/postgresql11-server
	devel/git-base
	devel/git-docs
	devel/cmake
	lang/elixir
	security/acmesh
	security/sudo
	shells/mksh
	www/nginx
	```

	Copy the rc.d scripts to the right directory:

	```
	# cp /usr/pkg/share/examples/rc.d/nginx /usr/pkg/share/examples/rc.d/pgsql /etc/rc.d
	```

	Add nginx and Postgres to `/etc/rc.conf`:

	```
	nginx=YES
	pgsql=YES
	```

	## Configuring postgres

	First, run `# /etc/rc.d/pgsql start`. Then, `$ sudo -Hu pgsql -g pgsql createdb`.

	+### Install media / graphics packages (optional, see [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md))
	+
	+`# pkgin install ImageMagick ffmpeg4 p5-Image-ExifTool`
	+
	## Configuring Pleroma

	Create a user for Pleroma:

	```
	# groupadd pleroma
	# useradd -d /home/pleroma -m -g pleroma -s /usr/pkg/bin/mksh pleroma
	# echo 'export LC_ALL="en_GB.UTF-8"' >> /home/pleroma/.profile
	# su -l pleroma -c $SHELL
	```

	Clone the repository:

	```
	$ cd /home/pleroma
	$ git clone -b stable https://git.pleroma.social/pleroma/pleroma.git
	```

	Configure Pleroma. Note that you need a domain name at this point:

	```
	$ cd /home/pleroma/pleroma
	$ mix deps.get
	$ mix pleroma.instance gen # You will be asked a few questions here.
	```

	Since Postgres is configured, we can now initialize the database. There should
	now be a file in `config/setup_db.psql` that makes this easier. Edit it, and
	change the password to a password of your choice. Make sure it is secure, since
	it'll be protecting your database. Now initialize the database:

	```
	$ sudo -Hu pgsql -g pgsql psql -f config/setup_db.psql
	```

	Postgres allows connections from all users without a password by default. To
	fix this, edit `/usr/pkg/pgsql/data/pg_hba.conf`. Change every `trust` to
	`password`.

	Once this is done, restart Postgres with `# /etc/rc.d/pgsql restart`.

	Run the database migrations.
	You will need to do this whenever you update with `git pull`:

	```
	$ MIX_ENV=prod mix ecto.migrate
	```

	## Configuring nginx

	Install the example configuration file
	`/home/pleroma/pleroma/installation/pleroma.nginx` to
	`/usr/pkg/etc/nginx.conf`.

	Note that it will need to be wrapped in a `http {}` block. You should add
	settings for the nginx daemon outside of the http block, for example:

	```
	user nginx nginx;
	error_log /var/log/nginx/error.log;
	worker_processes 4;

	events {
	}
	```

	Edit the defaults:

	* Change `ssl_certificate` and `ssl_trusted_certificate` to
	`/etc/nginx/tls/fullchain`.
	* Change `ssl_certificate_key` to `/etc/nginx/tls/key`.
	* Change `example.tld` to your instance's domain name.

	## Configuring acme.sh

	We'll be using acme.sh in Stateless Mode for TLS certificate renewal.

	First, get your account fingerprint:

	```
	$ sudo -Hu nginx -g nginx acme.sh --register-account
	```

	You need to add the following to your nginx configuration for the server
	running on port 80:

	```
	location ~ ^/\.well-known/acme-challenge/([-_a-zA-Z0-9]+)$ {
	default_type text/plain;
	return 200 "$1.6fXAG9VyG0IahirPEU2ZerUtItW2DHzDzD9wZaEKpqd";
	}
	```

	Replace the string after after `$1.` with your fingerprint.

	Start nginx:

	```
	# /etc/rc.d/nginx start
	```

	It should now be possible to issue a cert (replace `example.com`
	with your domain name):

	```
	$ sudo -Hu nginx -g nginx acme.sh --issue -d example.com --stateless
	```

	Let's add auto-renewal to `/etc/daily.local`
	(replace `example.com` with your domain):

	```
	/usr/pkg/bin/sudo -Hu nginx -g nginx \
	/usr/pkg/sbin/acme.sh -r \
	-d example.com \
	--cert-file /etc/nginx/tls/cert \
	--key-file /etc/nginx/tls/key \
	--ca-file /etc/nginx/tls/ca \
	--fullchain-file /etc/nginx/tls/fullchain \
	--stateless
	```

	## Creating a startup script for Pleroma

	Copy the startup script to the correct location and make sure it's executable:

	```
	# cp /home/pleroma/pleroma/installation/netbsd/rc.d/pleroma /etc/rc.d/pleroma
	# chmod +x /etc/rc.d/pleroma
	```

	Add the following to `/etc/rc.conf`:

	```
	pleroma=YES
	pleroma_home="/home/pleroma"
	pleroma_user="pleroma"
	```

	Run `# /etc/rc.d/pleroma start` to start Pleroma.

	## Conclusion

	Restart nginx with `# /etc/rc.d/nginx restart` and you should be up and running.

	If you need further help, contact niaa on freenode.

	Make sure your time is in sync, or other instances will receive your posts with
	incorrect timestamps. You should have ntpd running.

	## Instances running NetBSD

	* <https://catgirl.science>

	#### Further reading

	{! backend/installation/further_reading.include !}

	## 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/docs/installation/openbsd_en.md b/docs/installation/openbsd_en.md
	index eee452845..8092ac379 100644
	--- a/docs/installation/openbsd_en.md
	+++ b/docs/installation/openbsd_en.md
	@@ -1,253 +1,267 @@
	# Installing on OpenBSD

	This guide describes the installation and configuration of pleroma (and the required software to run it) on a single OpenBSD 6.6 server.

	For any additional information regarding commands and configuration files mentioned here, check the man pages [online](https://man.openbsd.org/) or directly on your server with the man command.

	#### Required software

	The following packages need to be installed:

	* elixir
	* gmake
	- * ImageMagick
	* git
	* postgresql-server
	* postgresql-contrib
	* cmake
	+ * ffmpeg
	+ * ImageMagick

	To install them, run the following command (with doas or as root):

	```
	-pkg_add elixir gmake ImageMagick git postgresql-server postgresql-contrib cmake
	+pkg_add elixir gmake git postgresql-server postgresql-contrib cmake ffmpeg ImageMagick
	```

	Pleroma requires a reverse proxy, OpenBSD has relayd in base (and is used in this guide) and packages/ports are available for nginx (www/nginx) and apache (www/apache-httpd). Independently of the reverse proxy, [acme-client(1)](https://man.openbsd.org/acme-client) can be used to get a certificate from Let's Encrypt.

	+#### Optional software
	+
	+Per [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md):
	+ * ImageMagick
	+ * ffmpeg
	+ * exiftool
	+
	+To install the above:
	+
	+```
	+pkg_add ImageMagick ffmpeg p5-Image-ExifTool
	+```
	+
	#### Creating the pleroma user
	Pleroma will be run by a dedicated user, \_pleroma. Before creating it, insert the following lines in login.conf:
	```
	pleroma:\
	:datasize-max=1536M:\
	:datasize-cur=1536M:\
	:openfiles-max=4096
	```
	This creates a "pleroma" login class and sets higher values than default for datasize and openfiles (see [login.conf(5)](https://man.openbsd.org/login.conf)), this is required to avoid having pleroma crash some time after starting.

	Create the \_pleroma user, assign it the pleroma login class and create its home directory (/home/\_pleroma/): `useradd -m -L pleroma _pleroma`

	#### Clone pleroma's directory
	Enter a shell as the \_pleroma user. As root, run `su _pleroma -;cd`. Then clone the repository with `git clone -b stable https://git.pleroma.social/pleroma/pleroma.git`. Pleroma is now installed in /home/\_pleroma/pleroma/, it will be configured and started at the end of this guide.

	#### PostgreSQL
	Start a shell as the \_postgresql user (as root run `su _postgresql -` then run the `initdb` command to initialize postgresql:
	You will need to specify pgdata directory to the default (/var/postgresql/data) with the `-D <path>` and set the user to postgres with the `-U <username>` flag. This can be done as follows:

	```
	initdb -D /var/postgresql/data -U postgres
	```
	If you are not using the default directory, you will have to update the `datadir` variable in the /etc/rc.d/postgresql script.

	When this is done, enable postgresql so that it starts on boot and start it. As root, run:
	```
	rcctl enable postgresql
	rcctl start postgresql
	```
	To check that it started properly and didn't fail right after starting, you can run `ps aux \| grep postgres`, there should be multiple lines of output.

	#### httpd
	httpd will have three fuctions:

	* redirect requests trying to reach the instance over http to the https URL
	* serve a robots.txt file
	* get Let's Encrypt certificates, with acme-client

	Insert the following config in httpd.conf:
	```
	# $OpenBSD: httpd.conf,v 1.17 2017/04/16 08:50:49 ajacoutot Exp $

	ext_inet="<IPv4 address>"
	ext_inet6="<IPv6 address>"

	server "default" {
	listen on $ext_inet port 80 # Comment to disable listening on IPv4
	listen on $ext_inet6 port 80 # Comment to disable listening on IPv6
	listen on 127.0.0.1 port 80 # Do NOT comment this line

	log syslog
	directory no index

	location "/.well-known/acme-challenge/*" {
	root "/acme"
	request strip 2
	}

	location "/robots.txt" { root "/htdocs/local/" }
	location "/*" { block return 302 "https://$HTTP_HOST$REQUEST_URI" }
	}

	types {
	}
	```
	Do not forget to change <IPv4/6 address\> to your server's address(es). If httpd should only listen on one protocol family, comment one of the two first listen options.

	Create the /var/www/htdocs/local/ folder and write the content of your robots.txt in /var/www/htdocs/local/robots.txt.
	Check the configuration with `httpd -n`, if it is OK enable and start httpd (as root):
	```
	rcctl enable httpd
	rcctl start httpd
	```

	#### acme-client
	acme-client is used to get SSL/TLS certificates from Let's Encrypt.
	Insert the following configuration in /etc/acme-client.conf:
	```
	#
	# $OpenBSD: acme-client.conf,v 1.4 2017/03/22 11:14:14 benno Exp $
	#

	authority letsencrypt-<domain name> {
	#agreement url "https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf"
	api url "https://acme-v02.api.letsencrypt.org/directory"
	account key "/etc/acme/letsencrypt-privkey-<domain name>.pem"
	}

	domain <domain name> {
	domain key "/etc/ssl/private/<domain name>.key"
	domain certificate "/etc/ssl/<domain name>.crt"
	domain full chain certificate "/etc/ssl/<domain name>.fullchain.pem"
	sign with letsencrypt-<domain name>
	challengedir "/var/www/acme/"
	}
	```
	Replace <domain name\> by the domain name you'll use for your instance. As root, run `acme-client -n` to check the config, then `acme-client -ADv <domain name>` to create account and domain keys, and request a certificate for the first time.
	Make acme-client run everyday by adding it in /etc/daily.local. As root, run the following command: `echo "acme-client <domain name>" >> /etc/daily.local`.

	Relayd will look for certificates and keys based on the address it listens on (see next part), the easiest way to make them available to relayd is to create a link, as root run:
	```
	ln -s /etc/ssl/<domain name>.fullchain.pem /etc/ssl/<IP address>.crt
	ln -s /etc/ssl/private/<domain name>.key /etc/ssl/private/<IP address>.key
	```
	This will have to be done for each IPv4 and IPv6 address relayd listens on.

	#### relayd
	relayd will be used as the reverse proxy sitting in front of pleroma.
	Insert the following configuration in /etc/relayd.conf:
	```
	# $OpenBSD: relayd.conf,v 1.4 2018/03/23 09:55:06 claudio Exp $

	ext_inet="<IPv4 address>"
	ext_inet6="<IPv6 address>"

	table <pleroma_server> { 127.0.0.1 }
	table <httpd_server> { 127.0.0.1 }

	http protocol plerup { # Protocol for upstream pleroma server
	#tcp { nodelay, sack, socket buffer 65536, backlog 128 } # Uncomment and adjust as you see fit
	tls ciphers "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305"
	tls ecdhe secp384r1

	# Forward some paths to the local server (as pleroma won't respond to them as you might want)
	pass request quick path "/robots.txt" forward to <httpd_server>

	# Append a bunch of headers
	match request header append "X-Forwarded-For" value "$REMOTE_ADDR" # This two header and the next one are not strictly required by pleroma but adding them won't hurt
	match request header append "X-Forwarded-By" value "$SERVER_ADDR:$SERVER_PORT"

	match response header append "X-XSS-Protection" value "1; mode=block"
	match response header append "X-Permitted-Cross-Domain-Policies" value "none"
	match response header append "X-Frame-Options" value "DENY"
	match response header append "X-Content-Type-Options" value "nosniff"
	match response header append "Referrer-Policy" value "same-origin"
	match response header append "X-Download-Options" value "noopen"
	match response header append "Content-Security-Policy" value "default-src 'none'; base-uri 'self'; form-action 'self'; img-src 'self' data: https:; media-src 'self' https:; style-src 'self' 'unsafe-inline'; font-src 'self'; script-src 'self'; connect-src 'self' wss://CHANGEME.tld; upgrade-insecure-requests;" # Modify "CHANGEME.tld" and set your instance's domain here
	match request header append "Connection" value "upgrade"
	#match response header append "Strict-Transport-Security" value "max-age=31536000; includeSubDomains" # Uncomment this only after you get HTTPS working.

	# If you do not want remote frontends to be able to access your Pleroma backend server, comment these lines
	match response header append "Access-Control-Allow-Origin" value "*"
	match response header append "Access-Control-Allow-Methods" value "POST, PUT, DELETE, GET, PATCH, OPTIONS"
	match response header append "Access-Control-Allow-Headers" value "Authorization, Content-Type, Idempotency-Key"
	match response header append "Access-Control-Expose-Headers" value "Link, X-RateLimit-Reset, X-RateLimit-Limit, X-RateLimit-Remaining, X-Request-Id"
	# Stop commenting lines here
	}

	relay wwwtls {
	listen on $ext_inet port https tls # Comment to disable listening on IPv4
	listen on $ext_inet6 port https tls # Comment to disable listening on IPv6

	protocol plerup

	forward to <pleroma_server> port 4000 check http "/" code 200
	forward to <httpd_server> port 80 check http "/robots.txt" code 200
	}
	```
	Again, change <IPv4/6 address\> to your server's address(es) and comment one of the two listen options if needed. Also change wss://CHANGEME.tld to wss://<your instance's domain name\>.
	Check the configuration with `relayd -n`, if it is OK enable and start relayd (as root):
	```
	rcctl enable relayd
	rcctl start relayd
	```

	#### pf
	Enabling and configuring pf is highly recommended.
	In /etc/pf.conf, insert the following configuration:
	```
	# Macros
	if="<network interface>"
	authorized_ssh_clients="any"

	# Skip traffic on loopback interface
	set skip on lo

	# Default behavior
	set block-policy drop
	block in log all
	pass out quick

	# Security features
	match in all scrub (no-df random-id)
	block in log from urpf-failed

	# Rules
	pass in quick on $if inet proto icmp to ($if) icmp-type { echoreq unreach paramprob trace } # ICMP
	pass in quick on $if inet6 proto icmp6 to ($if) icmp6-type { echoreq unreach paramprob timex toobig } # ICMPv6
	pass in quick on $if proto tcp to ($if) port { http https } # relayd/httpd
	pass in quick on $if proto tcp from $authorized_ssh_clients to ($if) port ssh
	```
	Replace <network interface\> by your server's network interface name (which you can get with ifconfig). Consider replacing the content of the authorized\_ssh\_clients macro by, for exemple, your home IP address, to avoid SSH connection attempts from bots.

	Check pf's configuration by running `pfctl -nf /etc/pf.conf`, load it with `pfctl -f /etc/pf.conf` and enable pf at boot with `rcctl enable pf`.

	#### Configure and start pleroma
	Enter a shell as \_pleroma (as root `su _pleroma -`) and enter pleroma's installation directory (`cd ~/pleroma/`).

	Then follow the main installation guide:

	* run `mix deps.get`
	* run `mix pleroma.instance gen` and enter your instance's information when asked
	* copy config/generated\_config.exs to config/prod.secret.exs. The default values should be sufficient but you should edit it and check that everything seems OK.
	* exit your current shell back to a root one and run `psql -U postgres -f /home/_pleroma/pleroma/config/setup_db.psql` to setup the database.
	* return to a \_pleroma shell into pleroma's installation directory (`su _pleroma -;cd ~/pleroma`) and run `MIX_ENV=prod mix ecto.migrate`

	As \_pleroma in /home/\_pleroma/pleroma, you can now run `LC_ALL=en_US.UTF-8 MIX_ENV=prod mix phx.server` to start your instance.
	In another SSH session/tmux window, check that it is working properly by running `ftp -MVo - http://127.0.0.1:4000/api/v1/instance`, you should get json output. Double-check that uri's value is your instance's domain name.

	##### Starting pleroma at boot
	An rc script to automatically start pleroma at boot hasn't been written yet, it can be run in a tmux session (tmux is in base).


	#### Create administrative user

	If your instance is up and running, you can create your first user with administrative rights with the following command as the \_pleroma user.
	```
	LC_ALL=en_US.UTF-8 MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```

	#### Further reading

	{! backend/installation/further_reading.include !}

	## 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/docs/installation/openbsd_fi.md b/docs/installation/openbsd_fi.md
	index b5b5056a9..01cf34ab4 100644
	--- a/docs/installation/openbsd_fi.md
	+++ b/docs/installation/openbsd_fi.md
	@@ -1,110 +1,121 @@
	# Pleroman asennus OpenBSD:llä

	Tarvitset:
	* Oman domainin
	* OpenBSD 6.3 -serverin
	* Auttavan ymmärryksen unix-järjestelmistä

	Komennot, joiden edessä on '#', tulee ajaa käyttäjänä `root`. Tämä on
	suositeltavaa tehdä komennon `doas` avulla, katso `doas (1)` ja `doas.conf (5)`.
	Tästä eteenpäin oletuksena on, että domain "esimerkki.com" osoittaa
	serverin IP-osoitteeseen.

	Jos asennuksen kanssa on ongelmia, IRC-kanava #pleroma Freenodessa tai
	Matrix-kanava #freenode_#pleroma:matrix.org ovat hyviä paikkoja löytää apua
	(englanniksi), `/msg eal kukkuu` jos haluat välttämättä puhua härmää.

	Asenna tarvittava ohjelmisto:

	-`# pkg_add git elixir gmake postgresql-server-10.3 postgresql-contrib-10.3 cmake`
	+`# pkg_add git elixir gmake postgresql-server-10.3 postgresql-contrib-10.3 cmake ffmpeg ImageMagick`
	+
	+#### Optional software
	+
	+[`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md):
	+ * ImageMagick
	+ * ffmpeg
	+ * exiftool
	+
	+Asenna tarvittava ohjelmisto:
	+
	+`# pkg_add ImageMagick ffmpeg p5-Image-ExifTool`

	Luo postgresql-tietokanta:

	`# su - _postgresql`

	`$ mkdir /var/postgresql/data`

	`$ initdb -D /var/postgresql/data -E UTF8`

	`$ createdb`

	Käynnistä tietokanta ja aseta se käynnistymään automaattisesti.

	`# rcctl start postgresql`

	`# rcctl enable postgresql`

	Luo käyttäjä pleromaa varten (kysyy muutaman kysymyksen):

	`# adduser pleroma`

	Vaihda pleroma-käyttäjään ja mene kotihakemistoosi:

	`# su - pleroma`

	Lataa pleroman lähdekoodi:

	`$ git clone -b stable https://git.pleroma.social/pleroma/pleroma.git`

	`$ cd pleroma`

	Asenna tarvittavat elixir-kirjastot:

	`$ mix deps.get`

	`$ mix deps.compile`

	Luo tarvittava konfiguraatio:

	`$ mix generate_config`

	`$ cp config/generated_config.exs config/prod.secret.exs`

	Aja luodut tietokantakomennot:

	`# su _postgres -c 'psql -f config/setup_db.psql'`

	`$ MIX_ENV=prod mix ecto.migrate`

	Käynnistä pleroma-prosessi:

	`$ MIX_ENV=prod mix compile`

	`$ MIX_ENV=prod mix phx.server`

	Tässä vaiheessa on hyvä tarkistaa että asetukset ovat oikein. Avaa selaimella,
	curlilla tai vastaavalla työkalulla `esimerkki.com:4000/api/v1/instance` ja katso
	että kohta "uri" on "https://esimerkki.com".

	Huom! Muista varmistaa että muuttuja MIX_ENV on "prod" mix-komentoja ajaessasi.
	Mix lukee oikean konfiguraatiotiedoston sen mukaisesti.

	Ohessa enimmäkseen toimivaksi todettu rc.d-skripti pleroman käynnistämiseen.
	Kirjoita se tiedostoon /etc/rc.d/pleroma. Tämän jälkeen aja
	`# chmod +x /etc/rc.d/pleroma`, ja voit käynnistää pleroman komennolla
	`# /etc/rc.d/pleroma start`.

	```
	#!/bin/ksh
	#/etc/rc.d/pleroma

	daemon="cd /home/pleroma/pleroma;MIX_ENV=prod /usr/local/bin/elixir"
	daemon_flags="--detached /usr/local/bin/mix phx.server"
	daemon_user="pleroma"
	rc_reload="NO"
	rc_bg="YES"

	pexp="beam"

	. /etc/rc.d/rc.subr

	rc_cmd $1
	```

	Tämän jälkeen tarvitset enää HTTP-serverin välittämään kutsut pleroma-prosessille.
	Tiedostosta `install/pleroma.nginx` löytyy esimerkkikonfiguraatio, ja TLS-sertifikaatit
	saat ilmaiseksi esimerkiksi [letsencryptiltä](https://certbot.eff.org/lets-encrypt/opbsd-nginx.html).
	Nginx asentuu yksinkertaisesti komennolla `# pkg_add nginx`.

	Kun olet valmis, avaa https://esimerkki.com selaimessasi. Luo käyttäjä ja seuraa kiinnostavia
	tyyppejä muilla palvelimilla!
	diff --git a/docs/installation/optional/media_graphics_packages.md b/docs/installation/optional/media_graphics_packages.md
	new file mode 100644
	index 000000000..cb3d71188
	--- /dev/null
	+++ b/docs/installation/optional/media_graphics_packages.md
	@@ -0,0 +1,32 @@
	+# Optional software packages needed for specific functionality
	+
	+For specific Pleroma functionality (which is disabled by default) some or all of the below packages are required:
	+ * `ImageMagic`
	+ * `ffmpeg`
	+ * `exiftool`
	+
	+Please refer to documentation in `docs/installation` on how to install them on specific OS.
	+
	+Note: the packages are not required with the current default settings of Pleroma.
	+
	+## `ImageMagick`
	+
	+`ImageMagick` is a set of tools to create, edit, compose, or convert bitmap images.
	+
	+It is required for the following Pleroma features:
	+ * `Pleroma.Upload.Filters.Mogrify`, `Pleroma.Upload.Filters.Mogrifun` upload filters (related config: `Plaroma.Upload/filters` in `config/config.exs`)
	+ * Media preview proxy for still images (related config: `media_preview_proxy/enabled` in `config/config.exs`)
	+
	+## `ffmpeg`
	+
	+`ffmpeg` is software to record, convert and stream audio and video.
	+
	+It is required for the following Pleroma features:
	+ * Media preview proxy for videos (related config: `media_preview_proxy/enabled` in `config/config.exs`)
	+
	+## `exiftool`
	+
	+`exiftool` is media files metadata reader/writer.
	+
	+It is required for the following Pleroma features:
	+ * `Pleroma.Upload.Filters.Exiftool` upload filter (related config: `Plaroma.Upload/filters` in `config/config.exs`)
	diff --git a/docs/installation/otp_en.md b/docs/installation/otp_en.md
	index b7e3bb2ac..92584d80d 100644
	--- a/docs/installation/otp_en.md
	+++ b/docs/installation/otp_en.md
	@@ -1,292 +1,313 @@
	# 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)

	=== "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
	```

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

	+### Installing optional packages
	+
	+Per [`docs/installation/optional/media_graphics_packages.md`](docs/installation/optional/media_graphics_packages.md):
	+ * ImageMagick
	+ * ffmpeg
	+ * exiftool
	+
	+=== "Alpine"
	+ ```
	+ echo "http://nl.alpinelinux.org/alpine/latest-stable/community" >> /etc/apk/repositories
	+ apk update
	+ apk add imagemagick ffmpeg exiftool
	+ ```
	+
	+=== "Debian/Ubuntu"
	+ ```
	+ apt install imagemagick ffmpeg libimage-exiftool-perl
	+ ```
	+
	## 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).

	=== "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
	```

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

	#### (Optional) Performance configuration
	It is encouraged to check [Optimizing your PostgreSQL performance](../configuration/postgresql.md) document, for tips on PostgreSQL tuning.

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

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

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

	```elixir
	+#
	+config :pleroma, Pleroma.Repo,
	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

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

	=== "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

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

	=== "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

	=== "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
	```

	=== "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
	```

	=== "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
	```

	=== "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

	{! backend/installation/further_reading.include !}

	## 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/installation/pleroma.vcl b/installation/pleroma.vcl
	index 154747aa6..13dad784c 100644
	--- a/installation/pleroma.vcl
	+++ b/installation/pleroma.vcl
	@@ -1,147 +1,151 @@
	+# Recommended varnishncsa logging format: '%h %l %u %t "%m %{X-Forwarded-Proto}i://%{Host}i%U%q %H" %s %b "%{Referer}i" "%{User-agent}i"'
	vcl 4.1;
	import std;

	backend default {
	.host = "127.0.0.1";
	.port = "4000";
	}

	# ACL for IPs that are allowed to PURGE data from the cache
	acl purge {
	"127.0.0.1";
	}

	sub vcl_recv {
	# Redirect HTTP to HTTPS
	if (std.port(server.ip) != 443) {
	+ set req.http.X-Forwarded-Proto = "http";
	set req.http.x-redir = "https://" + req.http.host + req.url;
	return (synth(750, ""));
	+ } else {
	+ set req.http.X-Forwarded-Proto = "https";
	}

	# CHUNKED SUPPORT
	if (req.http.Range ~ "bytes=") {
	set req.http.x-range = req.http.Range;
	}

	# Pipe if WebSockets request is coming through
	if (req.http.upgrade ~ "(?i)websocket") {
	return (pipe);
	}

	# Allow purging of the cache
	if (req.method == "PURGE") {
	if (!client.ip ~ purge) {
	return(synth(405,"Not allowed."));
	}
	return(purge);
	}
	}

	sub vcl_backend_response {
	# gzip text content
	if (beresp.http.content-type ~ "(text\|text/css\|application/x-javascript\|application/javascript)") {
	set beresp.do_gzip = true;
	}

	# Retry broken backend responses.
	if (beresp.status == 503) {
	set bereq.http.X-Varnish-Backend-503 = "1";
	return (retry);
	}

	# CHUNKED SUPPORT
	if (bereq.http.x-range ~ "bytes=" && beresp.status == 206) {
	set beresp.ttl = 10m;
	set beresp.http.CR = beresp.http.content-range;
	}

	# Don't cache objects that require authentication
	if (beresp.http.Authorization && !beresp.http.Cache-Control ~ "public") {
	set beresp.uncacheable = true;
	return (deliver);
	}

	# Allow serving cached content for 6h in case backend goes down
	set beresp.grace = 6h;

	# Do not cache 5xx responses
	if (beresp.status == 500 \|\| beresp.status == 502 \|\| beresp.status == 503 \|\| beresp.status == 504) {
	set beresp.uncacheable = true;
	return (abandon);
	}

	# Do not cache redirects and errors
	if ((beresp.status >= 300) && (beresp.status < 500)) {
	set beresp.uncacheable = true;
	set beresp.ttl = 30s;
	return (deliver);
	}
	}

	# The synthetic response for 301 redirects
	sub vcl_synth {
	if (resp.status == 750) {
	set resp.status = 301;
	set resp.http.Location = req.http.x-redir;
	return(deliver);
	}
	}

	# Ensure WebSockets through the pipe do not close prematurely
	sub vcl_pipe {
	if (req.http.upgrade) {
	set bereq.http.upgrade = req.http.upgrade;
	set bereq.http.connection = req.http.connection;
	}
	}

	sub vcl_hash {
	# CHUNKED SUPPORT
	if (req.http.x-range ~ "bytes=") {
	hash_data(req.http.x-range);
	unset req.http.Range;
	}
	}

	sub vcl_backend_fetch {
	# Be more lenient for slow servers on the fediverse
	- if bereq.url ~ "^/proxy/" {
	+ if (bereq.url ~ "^/proxy/") {
	set bereq.first_byte_timeout = 300s;
	}

	# CHUNKED SUPPORT
	if (bereq.http.x-range) {
	set bereq.http.Range = bereq.http.x-range;
	}

	if (bereq.retries == 0) {
	# Clean up the X-Varnish-Backend-503 flag that is used internally
	# to mark broken backend responses that should be retried.
	unset bereq.http.X-Varnish-Backend-503;
	} else {
	if (bereq.http.X-Varnish-Backend-503) {
	if (bereq.method != "POST" &&
	std.healthy(bereq.backend) &&
	bereq.retries <= 4) {
	# Flush broken backend response flag & try again.
	unset bereq.http.X-Varnish-Backend-503;
	} else {
	return (abandon);
	}
	}
	}
	}

	sub vcl_deliver {
	# CHUNKED SUPPORT
	if (resp.http.CR) {
	set resp.http.Content-Range = resp.http.CR;
	unset resp.http.CR;
	}
	}

	sub vcl_backend_error {
	# Retry broken backend responses.
	set bereq.http.X-Varnish-Backend-503 = "1";
	return (retry);
	}
	diff --git a/lib/mix/tasks/pleroma/relay.ex b/lib/mix/tasks/pleroma/relay.ex
	index a6d8d6c1c..bb808ca47 100644
	--- a/lib/mix/tasks/pleroma/relay.ex
	+++ b/lib/mix/tasks/pleroma/relay.ex
	@@ -1,50 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Relay do
	use Mix.Task
	import Mix.Pleroma
	alias Pleroma.Web.ActivityPub.Relay

	@shortdoc "Manages remote relays"
	@moduledoc File.read!("docs/administration/CLI_tasks/relay.md")

	def run(["follow", target]) do
	start_pleroma()

	with {:ok, _activity} <- Relay.follow(target) do
	# put this task to sleep to allow the genserver to push out the messages
	:timer.sleep(500)
	else
	{:error, e} -> shell_error("Error while following #{target}: #{inspect(e)}")
	end
	end

	- def run(["unfollow", target]) do
	+ def run(["unfollow", target \| rest]) do
	start_pleroma()

	- with {:ok, _activity} <- Relay.unfollow(target) do
	+ {options, [], []} =
	+ OptionParser.parse(
	+ rest,
	+ strict: [force: :boolean],
	+ aliases: [f: :force]
	+ )
	+
	+ force = Keyword.get(options, :force, false)
	+
	+ with {:ok, _activity} <- Relay.unfollow(target, %{force: force}) do
	# put this task to sleep to allow the genserver to push out the messages
	:timer.sleep(500)
	else
	{:error, e} -> shell_error("Error while following #{target}: #{inspect(e)}")
	end
	end

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

	with {:ok, list} <- Relay.list() do
	Enum.each(list, &print_relay_url/1)
	else
	{:error, e} -> shell_error("Error while fetching relay subscription list: #{inspect(e)}")
	end
	end

	defp print_relay_url(%{followed_back: false} = relay) do
	shell_info("#{relay.actor} - no Accept received (relay didn't follow back)")
	end

	defp print_relay_url(relay), do: shell_info(relay.actor)
	end
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index 00ec79a2a..e73d89350 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,280 +1,262 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Application do
	use Application

	import Cachex.Spec

	alias Pleroma.Config

	require Logger

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]
	@env Mix.env()

	def name, do: @name
	def version, do: @version
	def named_version, do: @name <> " " <> @version
	def repository, do: @repository

	def user_agent do
	if Process.whereis(Pleroma.Web.Endpoint) do
	case Config.get([:http, :user_agent], :default) do
	:default ->
	info = "#{Pleroma.Web.base_url()} <#{Config.get([:instance, :email], "")}>"
	named_version() <> "; " <> info

	custom ->
	custom
	end
	else
	# fallback, if endpoint is not started yet
	"Pleroma Data Loader"
	end
	end

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	# Scrubbers are compiled at runtime and therefore will cause a conflict
	# every time the application is restarted, so we disable module
	# conflicts at runtime
	Code.compiler_options(ignore_module_conflict: true)
	# Disable warnings_as_errors at runtime, it breaks Phoenix live reload
	# due to protocol consolidation warnings
	Code.compiler_options(warnings_as_errors: false)
	Pleroma.Telemetry.Logger.attach()
	Config.Holder.save_default()
	Pleroma.HTML.compile_scrubbers()
	Pleroma.Config.Oban.warn()
	Config.DeprecationWarnings.warn()
	Pleroma.Plugs.HTTPSecurityPlug.warn_if_disabled()
	Pleroma.ApplicationRequirements.verify!()
	setup_instrumenters()
	load_custom_modules()
	- check_system_commands()
	Pleroma.Docs.JSON.compile()

	adapter = Application.get_env(:tesla, :adapter)

	if adapter == Tesla.Adapter.Gun do
	if version = Pleroma.OTPVersion.version() do
	[major, minor] =
	version
	\|> String.split(".")
	\|> Enum.map(&String.to_integer/1)
	\|> Enum.take(2)

	if (major == 22 and minor < 2) or major < 22 do
	raise "
	!!!OTP VERSION WARNING!!!
	You are using gun adapter with OTP version #{version}, which doesn't support correct handling of unordered certificates chains. Please update your Erlang/OTP to at least 22.2.
	"
	end
	else
	raise "
	!!!OTP VERSION WARNING!!!
	To support correct handling of unordered certificates chains - OTP version must be > 22.2.
	"
	end
	end

	# Define workers and child supervisors to be supervised
	children =
	[
	Pleroma.Repo,
	Config.TransferTask,
	Pleroma.Emoji,
	Pleroma.Plugs.RateLimiter.Supervisor
	] ++
	cachex_children() ++
	http_children(adapter, @env) ++
	[
	Pleroma.Stats,
	Pleroma.JobQueueMonitor,
	{Oban, Config.get(Oban)}
	] ++
	task_children(@env) ++
	dont_run_in_test(@env) ++
	chat_child(@env, chat_enabled?()) ++
	[
	Pleroma.Web.Endpoint,
	Pleroma.Gopher.Server
	]

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
	Supervisor.start_link(children, opts)
	end

	def load_custom_modules do
	dir = Config.get([:modules, :runtime_dir])

	if dir && File.exists?(dir) do
	dir
	\|> Pleroma.Utils.compile_dir()
	\|> case do
	{:error, _errors, _warnings} ->
	raise "Invalid custom modules"

	{:ok, modules, _warnings} ->
	if @env != :test do
	Enum.each(modules, fn mod ->
	Logger.info("Custom module loaded: #{inspect(mod)}")
	end)
	end

	:ok
	end
	end
	end

	defp setup_instrumenters do
	require Prometheus.Registry

	if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
	:ok =
	:telemetry.attach(
	"prometheus-ecto",
	[:pleroma, :repo, :query],
	&Pleroma.Repo.Instrumenter.handle_event/4,
	%{}
	)

	Pleroma.Repo.Instrumenter.setup()
	end

	Pleroma.Web.Endpoint.MetricsExporter.setup()
	Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
	Pleroma.Web.Endpoint.Instrumenter.setup()
	end

	defp cachex_children do
	[
	build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
	build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
	build_cachex("scrubber", limit: 2500),
	build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500),
	build_cachex("web_resp", limit: 2500),
	build_cachex("emoji_packs", expiration: emoji_packs_expiration(), limit: 10),
	build_cachex("failed_proxy_url", limit: 2500),
	build_cachex("banned_urls", default_ttl: :timer.hours(24 * 30), limit: 5_000)
	]
	end

	defp emoji_packs_expiration,
	do: expiration(default: :timer.seconds(5 * 60), interval: :timer.seconds(60))

	defp idempotency_expiration,
	do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))

	defp seconds_valid_interval,
	do: :timer.seconds(Config.get!([Pleroma.Captcha, :seconds_valid]))

	@spec build_cachex(String.t(), keyword()) :: map()
	def build_cachex(type, opts),
	do: %{
	id: String.to_atom("cachex_" <> type),
	start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
	type: :worker
	}

	defp chat_enabled?, do: Config.get([:chat, :enabled])

	defp dont_run_in_test(env) when env in [:test, :benchmark], do: []

	defp dont_run_in_test(_) do
	[
	{Registry,
	[
	name: Pleroma.Web.Streamer.registry(),
	keys: :duplicate,
	partitions: System.schedulers_online()
	]},
	Pleroma.Web.FedSockets.Supervisor
	]
	end

	defp chat_child(_env, true) do
	[Pleroma.Web.ChatChannel.ChatChannelState]
	end

	defp chat_child(_, _), do: []

	defp task_children(:test) do
	[
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	}
	]
	end

	defp task_children(_) do
	[
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	},
	%{
	id: :internal_fetch_init,
	start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
	restart: :temporary
	}
	]
	end

	# start hackney and gun pools in tests
	defp http_children(_, :test) do
	http_children(Tesla.Adapter.Hackney, nil) ++ http_children(Tesla.Adapter.Gun, nil)
	end

	defp http_children(Tesla.Adapter.Hackney, _) do
	pools = [:federation, :media]

	pools =
	if Config.get([Pleroma.Upload, :proxy_remote]) do
	[:upload \| pools]
	else
	pools
	end

	for pool <- pools do
	options = Config.get([:hackney_pools, pool])
	:hackney_pool.child_spec(pool, options)
	end
	end

	defp http_children(Tesla.Adapter.Gun, _) do
	Pleroma.Gun.ConnectionPool.children() ++
	[{Task, &Pleroma.HTTP.AdapterHelper.Gun.limiter_setup/0}]
	end

	defp http_children(_, _), do: []
	-
	- defp check_system_commands do
	- filters = Config.get([Pleroma.Upload, :filters])
	-
	- check_filter = fn filter, command_required ->
	- with true <- filter in filters,
	- false <- Pleroma.Utils.command_available?(command_required) do
	- Logger.error(
	- "#{filter} is specified in list of Pleroma.Upload filters, but the #{command_required} command is not found"
	- )
	- end
	- end
	-
	- check_filter.(Pleroma.Upload.Filters.Exiftool, "exiftool")
	- check_filter.(Pleroma.Upload.Filters.Mogrify, "mogrify")
	- check_filter.(Pleroma.Upload.Filters.Mogrifun, "mogrify")
	- end
	end
	diff --git a/lib/pleroma/application_requirements.ex b/lib/pleroma/application_requirements.ex
	index 16f62b6f5..b977257a3 100644
	--- a/lib/pleroma/application_requirements.ex
	+++ b/lib/pleroma/application_requirements.ex
	@@ -1,143 +1,205 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ApplicationRequirements do
	@moduledoc """
	The module represents the collection of validations to runs before start server.
	"""

	defmodule VerifyError, do: defexception([:message])

	+ alias Pleroma.Config
	+ alias Pleroma.Helpers.MediaHelper
	+
	import Ecto.Query

	require Logger

	@spec verify!() :: :ok \| VerifyError.t()
	def verify! do
	:ok
	- \|> check_confirmation_accounts!
	+ \|> check_system_commands!()
	+ \|> check_confirmation_accounts!()
	\|> check_migrations_applied!()
	\|> check_welcome_message_config!()
	\|> check_rum!()
	\|> handle_result()
	end

	defp handle_result(:ok), do: :ok
	defp handle_result({:error, message}), do: raise(VerifyError, message: message)

	defp check_welcome_message_config!(:ok) do
	if Pleroma.Config.get([:welcome, :email, :enabled], false) and
	not Pleroma.Emails.Mailer.enabled?() do
	Logger.error("""
	To send welcome email do you need to enable mail.
	\nconfig :pleroma, Pleroma.Emails.Mailer, enabled: true
	""")

	{:error, "The mail disabled."}
	else
	:ok
	end
	end

	defp check_welcome_message_config!(result), do: result

	# Checks account confirmation email
	#
	def check_confirmation_accounts!(:ok) do
	if Pleroma.Config.get([:instance, :account_activation_required]) &&
	not Pleroma.Config.get([Pleroma.Emails.Mailer, :enabled]) do
	Logger.error(
	- "Account activation enabled, but no Mailer settings enabled.\nPlease set config :pleroma, :instance, account_activation_required: false\nOtherwise setup and enable Mailer."
	+ "Account activation enabled, but no Mailer settings enabled.\n" <>
	+ "Please set config :pleroma, :instance, account_activation_required: false\n" <>
	+ "Otherwise setup and enable Mailer."
	)

	{:error,
	"Account activation enabled, but Mailer is disabled. Cannot send confirmation emails."}
	else
	:ok
	end
	end

	def check_confirmation_accounts!(result), do: result

	# Checks for pending migrations.
	#
	def check_migrations_applied!(:ok) do
	unless Pleroma.Config.get(
	[:i_am_aware_this_may_cause_data_loss, :disable_migration_check],
	false
	) do
	{_, res, _} =
	Ecto.Migrator.with_repo(Pleroma.Repo, fn repo ->
	down_migrations =
	Ecto.Migrator.migrations(repo)
	\|> Enum.reject(fn
	{:up, _, _} -> true
	{:down, _, _} -> false
	end)

	if length(down_migrations) > 0 do
	down_migrations_text =
	Enum.map(down_migrations, fn {:down, id, name} -> "- #{name} (#{id})\n" end)

	Logger.error(
	- "The following migrations were not applied:\n#{down_migrations_text}If you want to start Pleroma anyway, set\nconfig :pleroma, :i_am_aware_this_may_cause_data_loss, disable_migration_check: true"
	+ "The following migrations were not applied:\n#{down_migrations_text}" <>
	+ "If you want to start Pleroma anyway, set\n" <>
	+ "config :pleroma, :i_am_aware_this_may_cause_data_loss, disable_migration_check: true"
	)

	{:error, "Unapplied Migrations detected"}
	else
	:ok
	end
	end)

	res
	else
	:ok
	end
	end

	def check_migrations_applied!(result), do: result

	# Checks for settings of RUM indexes.
	#
	defp check_rum!(:ok) do
	{_, res, _} =
	Ecto.Migrator.with_repo(Pleroma.Repo, fn repo ->
	migrate =
	from(o in "columns",
	where: o.table_name == "objects",
	where: o.column_name == "fts_content"
	)
	\|> repo.exists?(prefix: "information_schema")

	setting = Pleroma.Config.get([:database, :rum_enabled], false)

	do_check_rum!(setting, migrate)
	end)

	res
	end

	defp check_rum!(result), do: result

	defp do_check_rum!(setting, migrate) do
	case {setting, migrate} do
	{true, false} ->
	Logger.error(
	- "Use `RUM` index is enabled, but were not applied migrations for it.\nIf you want to start Pleroma anyway, set\nconfig :pleroma, :database, rum_enabled: false\nOtherwise apply the following migrations:\n`mix ecto.migrate --migrations-path priv/repo/optional_migrations/rum_indexing/`"
	+ "Use `RUM` index is enabled, but were not applied migrations for it.\n" <>
	+ "If you want to start Pleroma anyway, set\n" <>
	+ "config :pleroma, :database, rum_enabled: false\n" <>
	+ "Otherwise apply the following migrations:\n" <>
	+ "`mix ecto.migrate --migrations-path priv/repo/optional_migrations/rum_indexing/`"
	)

	{:error, "Unapplied RUM Migrations detected"}

	{false, true} ->
	Logger.error(
	- "Detected applied migrations to use `RUM` index, but `RUM` isn't enable in settings.\nIf you want to use `RUM`, set\nconfig :pleroma, :database, rum_enabled: true\nOtherwise roll `RUM` migrations back.\n`mix ecto.rollback --migrations-path priv/repo/optional_migrations/rum_indexing/`"
	+ "Detected applied migrations to use `RUM` index, but `RUM` isn't enable in settings.\n" <>
	+ "If you want to use `RUM`, set\n" <>
	+ "config :pleroma, :database, rum_enabled: true\n" <>
	+ "Otherwise roll `RUM` migrations back.\n" <>
	+ "`mix ecto.rollback --migrations-path priv/repo/optional_migrations/rum_indexing/`"
	)

	{:error, "RUM Migrations detected"}

	_ ->
	:ok
	end
	end
	+
	+ defp check_system_commands!(:ok) do
	+ filter_commands_statuses = [
	+ check_filter(Pleroma.Upload.Filters.Exiftool, "exiftool"),
	+ check_filter(Pleroma.Upload.Filters.Mogrify, "mogrify"),
	+ check_filter(Pleroma.Upload.Filters.Mogrifun, "mogrify")
	+ ]
	+
	+ preview_proxy_commands_status =
	+ if !Config.get([:media_preview_proxy, :enabled]) or
	+ MediaHelper.missing_dependencies() == [] do
	+ true
	+ else
	+ Logger.error(
	+ "The following dependencies required by Media preview proxy " <>
	+ "(which is currently enabled) are not installed: " <>
	+ inspect(MediaHelper.missing_dependencies())
	+ )
	+
	+ false
	+ end
	+
	+ if Enum.all?([preview_proxy_commands_status \| filter_commands_statuses], & &1) do
	+ :ok
	+ else
	+ {:error,
	+ "System commands missing. Check logs and see `docs/installation` for more details."}
	+ end
	+ end
	+
	+ defp check_system_commands!(result), do: result
	+
	+ defp check_filter(filter, command_required) do
	+ filters = Config.get([Pleroma.Upload, :filters])
	+
	+ if filter in filters and not Pleroma.Utils.command_available?(command_required) do
	+ Logger.error(
	+ "#{filter} is specified in list of Pleroma.Upload filters, but the " <>
	+ "#{command_required} command is not found"
	+ )
	+
	+ false
	+ else
	+ true
	+ end
	+ end
	end
	diff --git a/lib/pleroma/emoji/pack.ex b/lib/pleroma/emoji/pack.ex
	index 0b3f8f00b..8f1989ada 100644
	--- a/lib/pleroma/emoji/pack.ex
	+++ b/lib/pleroma/emoji/pack.ex
	@@ -1,635 +1,636 @@
	defmodule Pleroma.Emoji.Pack do
	@derive {Jason.Encoder, only: [:files, :pack, :files_count]}
	defstruct files: %{},
	files_count: 0,
	pack_file: nil,
	path: nil,
	pack: %{},
	name: nil

	@type t() :: %__MODULE__{
	files: %{String.t() => Path.t()},
	files_count: non_neg_integer(),
	pack_file: Path.t(),
	path: Path.t(),
	pack: map(),
	name: String.t()
	}

	alias Pleroma.Emoji
	alias Pleroma.Emoji.Pack

	@spec create(String.t()) :: {:ok, t()} \| {:error, File.posix()} \| {:error, :empty_values}
	def create(name) do
	with :ok <- validate_not_empty([name]),
	dir <- Path.join(emoji_path(), name),
	:ok <- File.mkdir(dir) do
	%__MODULE__{pack_file: Path.join(dir, "pack.json")}
	\|> save_pack()
	end
	end

	defp paginate(entities, 1, page_size), do: Enum.take(entities, page_size)

	defp paginate(entities, page, page_size) do
	entities
	\|> Enum.chunk_every(page_size)
	\|> Enum.at(page - 1)
	end

	@spec show(keyword()) :: {:ok, t()} \| {:error, atom()}
	def show(opts) do
	name = opts[:name]

	with :ok <- validate_not_empty([name]),
	{:ok, pack} <- load_pack(name) do
	shortcodes =
	pack.files
	\|> Map.keys()
	\|> Enum.sort()
	\|> paginate(opts[:page], opts[:page_size])

	pack = Map.put(pack, :files, Map.take(pack.files, shortcodes))

	{:ok, validate_pack(pack)}
	end
	end

	@spec delete(String.t()) ::
	{:ok, [binary()]} \| {:error, File.posix(), binary()} \| {:error, :empty_values}
	def delete(name) do
	with :ok <- validate_not_empty([name]) do
	emoji_path()
	\|> Path.join(name)
	\|> File.rm_rf()
	end
	end

	@spec unpack_zip_emojies(list(tuple())) :: list(map())
	defp unpack_zip_emojies(zip_files) do
	Enum.reduce(zip_files, [], fn
	{_, path, s, _, _, _}, acc when elem(s, 2) == :regular ->
	with(
	filename <- Path.basename(path),
	shortcode <- Path.basename(filename, Path.extname(filename)),
	false <- Emoji.exist?(shortcode)
	) do
	[%{path: path, filename: path, shortcode: shortcode} \| acc]
	else
	_ -> acc
	end

	_, acc ->
	acc
	end)
	end

	@spec add_file(t(), String.t(), Path.t(), Plug.Upload.t()) ::
	{:ok, t()}
	\| {:error, File.posix() \| atom()}
	def add_file(%Pack{} = pack, _, _, %Plug.Upload{content_type: "application/zip"} = file) do
	with {:ok, zip_files} <- :zip.table(to_charlist(file.path)),
	[_ \| _] = emojies <- unpack_zip_emojies(zip_files),
	{:ok, tmp_dir} <- Pleroma.Utils.tmp_dir("emoji") do
	try do
	{:ok, _emoji_files} =
	:zip.unzip(
	to_charlist(file.path),
	[{:file_list, Enum.map(emojies, & &1[:path])}, {:cwd, tmp_dir}]
	)

	{_, updated_pack} =
	Enum.map_reduce(emojies, pack, fn item, emoji_pack ->
	emoji_file = %Plug.Upload{
	filename: item[:filename],
	path: Path.join(tmp_dir, item[:path])
	}

	{:ok, updated_pack} =
	do_add_file(
	emoji_pack,
	item[:shortcode],
	to_string(item[:filename]),
	emoji_file
	)

	{item, updated_pack}
	end)

	Emoji.reload()

	{:ok, updated_pack}
	after
	File.rm_rf(tmp_dir)
	end
	else
	{:error, _} = error ->
	error

	_ ->
	{:ok, pack}
	end
	end

	def add_file(%Pack{} = pack, shortcode, filename, %Plug.Upload{} = file) do
	with :ok <- validate_not_empty([shortcode, filename]),
	:ok <- validate_emoji_not_exists(shortcode),
	{:ok, updated_pack} <- do_add_file(pack, shortcode, filename, file) do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	defp do_add_file(pack, shortcode, filename, file) do
	with :ok <- save_file(file, pack, filename) do
	pack
	\|> put_emoji(shortcode, filename)
	\|> save_pack()
	end
	end

	@spec delete_file(t(), String.t()) ::
	{:ok, t()} \| {:error, File.posix() \| atom()}
	def delete_file(%Pack{} = pack, shortcode) do
	with :ok <- validate_not_empty([shortcode]),
	:ok <- remove_file(pack, shortcode),
	{:ok, updated_pack} <- pack \|> delete_emoji(shortcode) \|> save_pack() do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	@spec update_file(t(), String.t(), String.t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, File.posix() \| atom()}
	def update_file(%Pack{} = pack, shortcode, new_shortcode, new_filename, force) do
	with :ok <- validate_not_empty([shortcode, new_shortcode, new_filename]),
	{:ok, filename} <- get_filename(pack, shortcode),
	:ok <- validate_emoji_not_exists(new_shortcode, force),
	:ok <- rename_file(pack, filename, new_filename),
	{:ok, updated_pack} <-
	pack
	\|> delete_emoji(shortcode)
	\|> put_emoji(new_shortcode, new_filename)
	\|> save_pack() do
	Emoji.reload()
	{:ok, updated_pack}
	end
	end

	@spec import_from_filesystem() :: {:ok, [String.t()]} \| {:error, File.posix() \| atom()}
	def import_from_filesystem do
	emoji_path = emoji_path()

	with {:ok, %{access: :read_write}} <- File.stat(emoji_path),
	{:ok, results} <- File.ls(emoji_path) do
	names =
	results
	\|> Enum.map(&Path.join(emoji_path, &1))
	\|> Enum.reject(fn path ->
	File.dir?(path) and File.exists?(Path.join(path, "pack.json"))
	end)
	\|> Enum.map(&write_pack_contents/1)
	\|> Enum.reject(&is_nil/1)

	{:ok, names}
	else
	{:ok, %{access: _}} -> {:error, :no_read_write}
	e -> e
	end
	end

	- @spec list_remote(String.t()) :: {:ok, map()} \| {:error, atom()}
	- def list_remote(url) do
	- uri = url \|> String.trim() \|> URI.parse()
	+ @spec list_remote(keyword()) :: {:ok, map()} \| {:error, atom()}
	+ def list_remote(opts) do
	+ uri = opts[:url] \|> String.trim() \|> URI.parse()

	with :ok <- validate_shareable_packs_available(uri) do
	uri
	- \|> URI.merge("/api/pleroma/emoji/packs")
	+ \|> URI.merge("/api/pleroma/emoji/packs?page=#{opts[:page]}&page_size=#{opts[:page_size]}")
	\|> http_get()
	end
	end

	@spec list_local(keyword()) :: {:ok, map(), non_neg_integer()}
	def list_local(opts) do
	with {:ok, results} <- list_packs_dir() do
	all_packs =
	results
	\|> Enum.map(fn name ->
	case load_pack(name) do
	{:ok, pack} -> pack
	_ -> nil
	end
	end)
	\|> Enum.reject(&is_nil/1)

	packs =
	all_packs
	\|> paginate(opts[:page], opts[:page_size])
	\|> Map.new(fn pack -> {pack.name, validate_pack(pack)} end)

	{:ok, packs, length(all_packs)}
	end
	end

	@spec get_archive(String.t()) :: {:ok, binary()} \| {:error, atom()}
	def get_archive(name) do
	with {:ok, pack} <- load_pack(name),
	:ok <- validate_downloadable(pack) do
	{:ok, fetch_archive(pack)}
	end
	end

	@spec download(String.t(), String.t(), String.t()) :: {:ok, t()} \| {:error, atom()}
	def download(name, url, as) do
	uri = url \|> String.trim() \|> URI.parse()

	with :ok <- validate_shareable_packs_available(uri),
	- {:ok, remote_pack} <- uri \|> URI.merge("/api/pleroma/emoji/packs/#{name}") \|> http_get(),
	+ {:ok, remote_pack} <-
	+ uri \|> URI.merge("/api/pleroma/emoji/pack?name=#{name}") \|> http_get(),
	{:ok, %{sha: sha, url: url} = pack_info} <- fetch_pack_info(remote_pack, uri, name),
	{:ok, archive} <- download_archive(url, sha),
	pack <- copy_as(remote_pack, as \|\| name),
	{:ok, _} = unzip(archive, pack_info, remote_pack, pack) do
	# Fallback can't contain a pack.json file, since that would cause the fallback-src-sha256
	# in it to depend on itself
	if pack_info[:fallback] do
	save_pack(pack)
	else
	{:ok, pack}
	end
	end
	end

	@spec save_metadata(map(), t()) :: {:ok, t()} \| {:error, File.posix()}
	def save_metadata(metadata, %__MODULE__{} = pack) do
	pack
	\|> Map.put(:pack, metadata)
	\|> save_pack()
	end

	@spec update_metadata(String.t(), map()) :: {:ok, t()} \| {:error, File.posix()}
	def update_metadata(name, data) do
	with {:ok, pack} <- load_pack(name) do
	if fallback_sha_changed?(pack, data) do
	update_sha_and_save_metadata(pack, data)
	else
	save_metadata(data, pack)
	end
	end
	end

	@spec load_pack(String.t()) :: {:ok, t()} \| {:error, :not_found}
	def load_pack(name) do
	pack_file = Path.join([emoji_path(), name, "pack.json"])

	if File.exists?(pack_file) do
	pack =
	pack_file
	\|> File.read!()
	\|> from_json()
	\|> Map.put(:pack_file, pack_file)
	\|> Map.put(:path, Path.dirname(pack_file))
	\|> Map.put(:name, name)

	files_count =
	pack.files
	\|> Map.keys()
	\|> length()

	{:ok, Map.put(pack, :files_count, files_count)}
	else
	{:error, :not_found}
	end
	end

	@spec emoji_path() :: Path.t()
	defp emoji_path do
	[:instance, :static_dir]
	\|> Pleroma.Config.get!()
	\|> Path.join("emoji")
	end

	defp validate_emoji_not_exists(shortcode, force \\ false)
	defp validate_emoji_not_exists(_shortcode, true), do: :ok

	defp validate_emoji_not_exists(shortcode, _) do
	if Emoji.exist?(shortcode) do
	{:error, :already_exists}
	else
	:ok
	end
	end

	defp write_pack_contents(path) do
	pack = %__MODULE__{
	files: files_from_path(path),
	path: path,
	pack_file: Path.join(path, "pack.json")
	}

	case save_pack(pack) do
	{:ok, _pack} -> Path.basename(path)
	_ -> nil
	end
	end

	defp files_from_path(path) do
	txt_path = Path.join(path, "emoji.txt")

	if File.exists?(txt_path) do
	# There's an emoji.txt file, it's likely from a pack installed by the pack manager.
	# Make a pack.json file from the contents of that emoji.txt file

	# FIXME: Copy-pasted from Pleroma.Emoji/load_from_file_stream/2

	# Create a map of shortcodes to filenames from emoji.txt
	txt_path
	\|> File.read!()
	\|> String.split("\n")
	\|> Enum.map(&String.trim/1)
	\|> Enum.map(fn line ->
	case String.split(line, ~r/,\s*/) do
	# This matches both strings with and without tags
	# and we don't care about tags here
	[name, file \| _] ->
	file_dir_name = Path.dirname(file)

	if String.ends_with?(path, file_dir_name) do
	{name, Path.basename(file)}
	else
	{name, file}
	end

	_ ->
	nil
	end
	end)
	\|> Enum.reject(&is_nil/1)
	\|> Map.new()
	else
	# If there's no emoji.txt, assume all files
	# that are of certain extensions from the config are emojis and import them all
	pack_extensions = Pleroma.Config.get!([:emoji, :pack_extensions])
	Emoji.Loader.make_shortcode_to_file_map(path, pack_extensions)
	end
	end

	defp validate_pack(pack) do
	info =
	if downloadable?(pack) do
	archive = fetch_archive(pack)
	archive_sha = :crypto.hash(:sha256, archive) \|> Base.encode16()

	pack.pack
	\|> Map.put("can-download", true)
	\|> Map.put("download-sha256", archive_sha)
	else
	Map.put(pack.pack, "can-download", false)
	end

	Map.put(pack, :pack, info)
	end

	defp downloadable?(pack) do
	# If the pack is set as shared, check if it can be downloaded
	# That means that when asked, the pack can be packed and sent to the remote
	# Otherwise, they'd have to download it from external-src
	pack.pack["share-files"] &&
	Enum.all?(pack.files, fn {_, file} ->
	pack.path
	\|> Path.join(file)
	\|> File.exists?()
	end)
	end

	defp create_archive_and_cache(pack, hash) do
	files = ['pack.json' \| Enum.map(pack.files, fn {_, file} -> to_charlist(file) end)]

	{:ok, {_, result}} =
	:zip.zip('#{pack.name}.zip', files, [:memory, cwd: to_charlist(pack.path)])

	ttl_per_file = Pleroma.Config.get!([:emoji, :shared_pack_cache_seconds_per_file])
	overall_ttl = :timer.seconds(ttl_per_file * Enum.count(files))

	Cachex.put!(
	:emoji_packs_cache,
	pack.name,
	# if pack.json MD5 changes, the cache is not valid anymore
	%{hash: hash, pack_data: result},
	# Add a minute to cache time for every file in the pack
	ttl: overall_ttl
	)

	result
	end

	defp save_pack(pack) do
	with {:ok, json} <- Jason.encode(pack, pretty: true),
	:ok <- File.write(pack.pack_file, json) do
	{:ok, pack}
	end
	end

	defp from_json(json) do
	map = Jason.decode!(json)

	struct(__MODULE__, %{files: map["files"], pack: map["pack"]})
	end

	defp validate_shareable_packs_available(uri) do
	with {:ok, %{"links" => links}} <- uri \|> URI.merge("/.well-known/nodeinfo") \|> http_get(),
	# Get the actual nodeinfo address and fetch it
	{:ok, %{"metadata" => %{"features" => features}}} <-
	links \|> List.last() \|> Map.get("href") \|> http_get() do
	if Enum.member?(features, "shareable_emoji_packs") do
	:ok
	else
	{:error, :not_shareable}
	end
	end
	end

	defp validate_not_empty(list) do
	if Enum.all?(list, fn i -> is_binary(i) and i != "" end) do
	:ok
	else
	{:error, :empty_values}
	end
	end

	defp save_file(%Plug.Upload{path: upload_path}, pack, filename) do
	file_path = Path.join(pack.path, filename)
	create_subdirs(file_path)

	with {:ok, _} <- File.copy(upload_path, file_path) do
	:ok
	end
	end

	defp put_emoji(pack, shortcode, filename) do
	files = Map.put(pack.files, shortcode, filename)
	%{pack \| files: files, files_count: length(Map.keys(files))}
	end

	defp delete_emoji(pack, shortcode) do
	files = Map.delete(pack.files, shortcode)
	%{pack \| files: files}
	end

	defp rename_file(pack, filename, new_filename) do
	old_path = Path.join(pack.path, filename)
	new_path = Path.join(pack.path, new_filename)
	create_subdirs(new_path)

	with :ok <- File.rename(old_path, new_path) do
	remove_dir_if_empty(old_path, filename)
	end
	end

	defp create_subdirs(file_path) do
	if String.contains?(file_path, "/") do
	file_path
	\|> Path.dirname()
	\|> File.mkdir_p!()
	end
	end

	defp remove_file(pack, shortcode) do
	with {:ok, filename} <- get_filename(pack, shortcode),
	emoji <- Path.join(pack.path, filename),
	:ok <- File.rm(emoji) do
	remove_dir_if_empty(emoji, filename)
	end
	end

	defp remove_dir_if_empty(emoji, filename) do
	dir = Path.dirname(emoji)

	if String.contains?(filename, "/") and File.ls!(dir) == [] do
	File.rmdir!(dir)
	else
	:ok
	end
	end

	defp get_filename(pack, shortcode) do
	with %{^shortcode => filename} when is_binary(filename) <- pack.files,
	true <- pack.path \|> Path.join(filename) \|> File.exists?() do
	{:ok, filename}
	else
	_ -> {:error, :doesnt_exist}
	end
	end

	defp http_get(%URI{} = url), do: url \|> to_string() \|> http_get()

	defp http_get(url) do
	- with {:ok, %{body: body}} <- url \|> Pleroma.HTTP.get() do
	+ with {:ok, %{body: body}} <- Pleroma.HTTP.get(url, [], pool: :default) do
	Jason.decode(body)
	end
	end

	defp list_packs_dir do
	emoji_path = emoji_path()
	# Create the directory first if it does not exist. This is probably the first request made
	# with the API so it should be sufficient
	with {:create_dir, :ok} <- {:create_dir, File.mkdir_p(emoji_path)},
	{:ls, {:ok, results}} <- {:ls, File.ls(emoji_path)} do
	{:ok, Enum.sort(results)}
	else
	{:create_dir, {:error, e}} -> {:error, :create_dir, e}
	{:ls, {:error, e}} -> {:error, :ls, e}
	end
	end

	defp validate_downloadable(pack) do
	if downloadable?(pack), do: :ok, else: {:error, :cant_download}
	end

	defp copy_as(remote_pack, local_name) do
	path = Path.join(emoji_path(), local_name)

	%__MODULE__{
	name: local_name,
	path: path,
	files: remote_pack["files"],
	pack_file: Path.join(path, "pack.json")
	}
	end

	defp unzip(archive, pack_info, remote_pack, local_pack) do
	with :ok <- File.mkdir_p!(local_pack.path) do
	files = Enum.map(remote_pack["files"], fn {_, path} -> to_charlist(path) end)
	# Fallback cannot contain a pack.json file
	files = if pack_info[:fallback], do: files, else: ['pack.json' \| files]

	:zip.unzip(archive, cwd: to_charlist(local_pack.path), file_list: files)
	end
	end

	defp fetch_pack_info(remote_pack, uri, name) do
	case remote_pack["pack"] do
	%{"share-files" => true, "can-download" => true, "download-sha256" => sha} ->
	{:ok,
	%{
	sha: sha,
	- url: URI.merge(uri, "/api/pleroma/emoji/packs/#{name}/archive") \|> to_string()
	+ url: URI.merge(uri, "/api/pleroma/emoji/packs/archive?name=#{name}") \|> to_string()
	}}

	%{"fallback-src" => src, "fallback-src-sha256" => sha} when is_binary(src) ->
	{:ok,
	%{
	sha: sha,
	url: src,
	fallback: true
	}}

	_ ->
	{:error, "The pack was not set as shared and there is no fallback src to download from"}
	end
	end

	defp download_archive(url, sha) do
	with {:ok, %{body: archive}} <- Tesla.get(url) do
	if Base.decode16!(sha) == :crypto.hash(:sha256, archive) do
	{:ok, archive}
	else
	{:error, :invalid_checksum}
	end
	end
	end

	defp fetch_archive(pack) do
	hash = :crypto.hash(:md5, File.read!(pack.pack_file))

	case Cachex.get!(:emoji_packs_cache, pack.name) do
	%{hash: ^hash, pack_data: archive} -> archive
	_ -> create_archive_and_cache(pack, hash)
	end
	end

	defp fallback_sha_changed?(pack, data) do
	is_binary(data[:"fallback-src"]) and data[:"fallback-src"] != pack.pack["fallback-src"]
	end

	defp update_sha_and_save_metadata(pack, data) do
	with {:ok, %{body: zip}} <- Tesla.get(data[:"fallback-src"]),
	:ok <- validate_has_all_files(pack, zip) do
	fallback_sha = :sha256 \|> :crypto.hash(zip) \|> Base.encode16()

	data
	\|> Map.put("fallback-src-sha256", fallback_sha)
	\|> save_metadata(pack)
	end
	end

	defp validate_has_all_files(pack, zip) do
	with {:ok, f_list} <- :zip.unzip(zip, [:memory]) do
	# Check if all files from the pack.json are in the archive
	pack.files
	\|> Enum.all?(fn {_, from_manifest} ->
	List.keyfind(f_list, to_charlist(from_manifest), 0)
	end)
	\|> if(do: :ok, else: {:error, :incomplete})
	end
	end
	end
	diff --git a/lib/pleroma/helpers/media_helper.ex b/lib/pleroma/helpers/media_helper.ex
	index b6f35a24b..6b799173e 100644
	--- a/lib/pleroma/helpers/media_helper.ex
	+++ b/lib/pleroma/helpers/media_helper.ex
	@@ -1,150 +1,162 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Helpers.MediaHelper do
	@moduledoc """
	Handles common media-related operations.
	"""

	alias Pleroma.HTTP

	+ require Logger
	+
	+ def missing_dependencies do
	+ Enum.reduce([imagemagick: "convert", ffmpeg: "ffmpeg"], [], fn {sym, executable}, acc ->
	+ if Pleroma.Utils.command_available?(executable) do
	+ acc
	+ else
	+ [sym \| acc]
	+ end
	+ end)
	+ end
	+
	def image_resize(url, options) do
	with executable when is_binary(executable) <- System.find_executable("convert"),
	{:ok, args} <- prepare_image_resize_args(options),
	{:ok, env} <- HTTP.get(url, [], pool: :media),
	{:ok, fifo_path} <- mkfifo() do
	args = List.flatten([fifo_path, args])
	run_fifo(fifo_path, env, executable, args)
	else
	nil -> {:error, {:convert, :command_not_found}}
	{:error, _} = error -> error
	end
	end

	defp prepare_image_resize_args(
	%{max_width: max_width, max_height: max_height, format: "png"} = options
	) do
	quality = options[:quality] \|\| 85
	resize = Enum.join([max_width, "x", max_height, ">"])

	args = [
	"-resize",
	resize,
	"-quality",
	to_string(quality),
	"png:-"
	]

	{:ok, args}
	end

	defp prepare_image_resize_args(%{max_width: max_width, max_height: max_height} = options) do
	quality = options[:quality] \|\| 85
	resize = Enum.join([max_width, "x", max_height, ">"])

	args = [
	"-interlace",
	"Plane",
	"-resize",
	resize,
	"-quality",
	to_string(quality),
	"jpg:-"
	]

	{:ok, args}
	end

	defp prepare_image_resize_args(_), do: {:error, :missing_options}

	# Note: video thumbnail is intentionally not resized (always has original dimensions)
	def video_framegrab(url) do
	with executable when is_binary(executable) <- System.find_executable("ffmpeg"),
	{:ok, env} <- HTTP.get(url, [], pool: :media),
	{:ok, fifo_path} <- mkfifo(),
	args = [
	"-y",
	"-i",
	fifo_path,
	"-vframes",
	"1",
	"-f",
	"mjpeg",
	"-loglevel",
	"error",
	"-"
	] do
	run_fifo(fifo_path, env, executable, args)
	else
	nil -> {:error, {:ffmpeg, :command_not_found}}
	{:error, _} = error -> error
	end
	end

	defp run_fifo(fifo_path, env, executable, args) do
	pid =
	Port.open({:spawn_executable, executable}, [
	:use_stdio,
	:stream,
	:exit_status,
	:binary,
	args: args
	])

	fifo = Port.open(to_charlist(fifo_path), [:eof, :binary, :stream, :out])
	fix = Pleroma.Helpers.QtFastStart.fix(env.body)
	true = Port.command(fifo, fix)
	:erlang.port_close(fifo)
	loop_recv(pid)
	after
	File.rm(fifo_path)
	end

	defp mkfifo do
	path = Path.join(System.tmp_dir!(), "pleroma-media-preview-pipe-#{Ecto.UUID.generate()}")

	case System.cmd("mkfifo", [path]) do
	{_, 0} ->
	spawn(fifo_guard(path))
	{:ok, path}

	{_, err} ->
	{:error, {:fifo_failed, err}}
	end
	end

	defp fifo_guard(path) do
	pid = self()

	fn ->
	ref = Process.monitor(pid)

	receive do
	{:DOWN, ^ref, :process, ^pid, _} ->
	File.rm(path)
	end
	end
	end

	defp loop_recv(pid) do
	loop_recv(pid, <<>>)
	end

	defp loop_recv(pid, acc) do
	receive do
	{^pid, {:data, data}} ->
	loop_recv(pid, acc <> data)

	{^pid, {:exit_status, 0}} ->
	{:ok, acc}

	{^pid, {:exit_status, status}} ->
	{:error, status}
	after
	5000 ->
	:erlang.port_close(pid)
	{:error, :timeout}
	end
	end
	end
	diff --git a/lib/pleroma/http/web_push.ex b/lib/pleroma/http/web_push.ex
	new file mode 100644
	index 000000000..78148a12e
	--- /dev/null
	+++ b/lib/pleroma/http/web_push.ex
	@@ -0,0 +1,12 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.HTTP.WebPush do
	+ @moduledoc false
	+
	+ def post(url, payload, headers) do
	+ list_headers = Map.to_list(headers)
	+ Pleroma.HTTP.post(url, payload, list_headers)
	+ end
	+end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 03be61ccf..09ea80793 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2399 +1,2399 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query
	import Ecto, only: [assoc: 2]

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Delivery
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Emoji
	alias Pleroma.FollowingRelationship
	alias Pleroma.Formatter
	alias Pleroma.HTML
	alias Pleroma.Keys
	alias Pleroma.MFA
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.RelMe
	alias Pleroma.Workers.BackgroundWorker

	require Logger

	@type t :: %__MODULE__{}
	@type account_status ::
	:active
	\| :deactivated
	\| :password_reset_pending
	\| :confirmation_pending
	\| :approval_pending
	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/

	@strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
	@extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/

	# AP ID user relationships (blocks, mutes etc.)
	# Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
	@user_relationships_config [
	block: [
	blocker_blocks: :blocked_users,
	blockee_blocks: :blocker_users
	],
	mute: [
	muter_mutes: :muted_users,
	mutee_mutes: :muter_users
	],
	reblog_mute: [
	reblog_muter_mutes: :reblog_muted_users,
	reblog_mutee_mutes: :reblog_muter_users
	],
	notification_mute: [
	notification_muter_mutes: :notification_muted_users,
	notification_mutee_mutes: :notification_muter_users
	],
	# Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
	inverse_subscription: [
	subscribee_subscriptions: :subscriber_users,
	subscriber_subscriptions: :subscribee_users
	]
	]

	schema "users" do
	field(:bio, :string, default: "")
	field(:raw_bio, :string)
	field(:email, :string)
	field(:name, :string)
	field(:nickname, :string)
	field(:password_hash, :string)
	field(:password, :string, virtual: true)
	field(:password_confirmation, :string, virtual: true)
	field(:keys, :string)
	field(:public_key, :string)
	field(:ap_id, :string)
	field(:avatar, :map, default: %{})
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	field(:banner, :map, default: %{})
	field(:background, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	field(:following_count, :integer, default: 0)
	field(:locked, :boolean, default: false)
	field(:confirmation_pending, :boolean, default: false)
	field(:password_reset_pending, :boolean, default: false)
	field(:approval_pending, :boolean, default: false)
	field(:registration_reason, :string, default: nil)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:domain_blocks, {:array, :string}, default: [])
	field(:deactivated, :boolean, default: false)
	field(:no_rich_text, :boolean, default: false)
	field(:ap_enabled, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	field(:mastofe_settings, :map, default: nil)
	field(:uri, ObjectValidators.Uri, default: nil)
	field(:hide_followers_count, :boolean, default: false)
	field(:hide_follows_count, :boolean, default: false)
	field(:hide_followers, :boolean, default: false)
	field(:hide_follows, :boolean, default: false)
	field(:hide_favorites, :boolean, default: true)
	field(:unread_conversation_count, :integer, default: 0)
	field(:pinned_activities, {:array, :string}, default: [])
	field(:email_notifications, :map, default: %{"digest" => false})
	field(:mascot, :map, default: nil)
	field(:emoji, :map, default: %{})
	field(:pleroma_settings_store, :map, default: %{})
	field(:fields, {:array, :map}, default: [])
	field(:raw_fields, {:array, :map}, default: [])
	field(:discoverable, :boolean, default: false)
	field(:invisible, :boolean, default: false)
	field(:allow_following_move, :boolean, default: true)
	field(:skip_thread_containment, :boolean, default: false)
	field(:actor_type, :string, default: "Person")
	field(:also_known_as, {:array, :string}, default: [])
	field(:inbox, :string)
	field(:shared_inbox, :string)
	field(:accepts_chat_messages, :boolean, default: nil)

	embeds_one(
	:notification_settings,
	Pleroma.User.NotificationSetting,
	on_replace: :update
	)

	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	has_many(:deliveries, Delivery)

	has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
	has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)

	for {relationship_type,
	[
	{outgoing_relation, outgoing_relation_target},
	{incoming_relation, incoming_relation_source}
	]} <- @user_relationships_config do
	# Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
	# :notification_muter_mutes, :subscribee_subscriptions
	has_many(outgoing_relation, UserRelationship,
	foreign_key: :source_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
	# :notification_mutee_mutes, :subscriber_subscriptions
	has_many(incoming_relation, UserRelationship,
	foreign_key: :target_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
	# :notification_muted_users, :subscriber_users
	has_many(outgoing_relation_target, through: [outgoing_relation, :target])

	# Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
	# :notification_muter_users, :subscribee_users
	has_many(incoming_relation_source, through: [incoming_relation, :source])
	end

	# `:blocks` is deprecated (replaced with `blocked_users` relation)
	field(:blocks, {:array, :string}, default: [])
	# `:mutes` is deprecated (replaced with `muted_users` relation)
	field(:mutes, {:array, :string}, default: [])
	# `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
	field(:muted_reblogs, {:array, :string}, default: [])
	# `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
	field(:muted_notifications, {:array, :string}, default: [])
	# `:subscribers` is deprecated (replaced with `subscriber_users` relation)
	field(:subscribers, {:array, :string}, default: [])

	embeds_one(
	:multi_factor_authentication_settings,
	MFA.Settings,
	on_replace: :delete
	)

	timestamps()
	end

	for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
	@user_relationships_config do
	# `def blocked_users_relation/2`, `def muted_users_relation/2`,
	# `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
	# `def subscriber_users/2`
	def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
	target_users_query = assoc(user, unquote(outgoing_relation_target))

	if restrict_deactivated? do
	restrict_deactivated(target_users_query)
	else
	target_users_query
	end
	end

	# `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
	# `def notification_muted_users/2`, `def subscriber_users/2`
	def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> Repo.all()
	end

	# `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
	# `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`
	def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end
	end

	defdelegate following_count(user), to: FollowingRelationship
	defdelegate following(user), to: FollowingRelationship
	defdelegate following?(follower, followed), to: FollowingRelationship
	defdelegate following_ap_ids(user), to: FollowingRelationship
	defdelegate get_follow_requests(user), to: FollowingRelationship
	defdelegate search(query, opts \\ []), to: User.Search

	@doc """
	Dumps Flake Id to SQL-compatible format (16-byte UUID).
	E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
	"""
	def binary_id(source_id) when is_binary(source_id) do
	with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
	dumped_id
	else
	_ -> source_id
	end
	end

	def binary_id(source_ids) when is_list(source_ids) do
	Enum.map(source_ids, &binary_id/1)
	end

	def binary_id(%User{} = user), do: binary_id(user.id)

	@doc "Returns status account"
	@spec account_status(User.t()) :: account_status()
	def account_status(%User{deactivated: true}), do: :deactivated
	def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
	def account_status(%User{local: true, approval_pending: true}), do: :approval_pending

	def account_status(%User{local: true, confirmation_pending: true}) do
	if Config.get([:instance, :account_activation_required]) do
	:confirmation_pending
	else
	:active
	end
	end

	def account_status(%User{}), do: :active

	@spec visible_for(User.t(), User.t() \| nil) ::
	:visible
	\| :invisible
	\| :restricted_unauthenticated
	\| :deactivated
	\| :confirmation_pending
	def visible_for(user, for_user \\ nil)

	def visible_for(%User{invisible: true}, _), do: :invisible

	def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible

	def visible_for(%User{} = user, nil) do
	if restrict_unauthenticated?(user) do
	:restrict_unauthenticated
	else
	visible_account_status(user)
	end
	end

	def visible_for(%User{} = user, for_user) do
	if superuser?(for_user) do
	:visible
	else
	visible_account_status(user)
	end
	end

	def visible_for(_, _), do: :invisible

	defp restrict_unauthenticated?(%User{local: true}) do
	Config.restrict_unauthenticated_access?(:profiles, :local)
	end

	defp restrict_unauthenticated?(%User{local: _}) do
	Config.restrict_unauthenticated_access?(:profiles, :remote)
	end

	defp visible_account_status(user) do
	status = account_status(user)

	if status in [:active, :password_reset_pending] do
	:visible
	else
	status
	end
	end

	@spec superuser?(User.t()) :: boolean()
	def superuser?(%User{local: true, is_admin: true}), do: true
	def superuser?(%User{local: true, is_moderator: true}), do: true
	def superuser?(_), do: false

	@spec invisible?(User.t()) :: boolean()
	def invisible?(%User{invisible: true}), do: true
	def invisible?(_), do: false

	def avatar_url(user, options \\ []) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} ->
	href

	_ ->
	unless options[:no_default] do
	Config.get([:assets, :default_user_avatar], "#{Web.base_url()}/images/avi.png")
	end
	end
	end

	def banner_url(user, options \\ []) do
	case user.banner do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
	end
	end

	# Should probably be renamed or removed
	def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"

	def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
	def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"

	@spec ap_following(User.t()) :: String.t()
	def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
	def ap_following(%User{} = user), do: "#{ap_id(user)}/following"

	@spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
	def restrict_deactivated(query) do
	from(u in query, where: u.deactivated != ^true)
	end

	defp truncate_fields_param(params) do
	if Map.has_key?(params, :fields) do
	Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
	else
	params
	end
	end

	defp truncate_if_exists(params, key, max_length) do
	if Map.has_key?(params, key) and is_binary(params[key]) do
	{value, _chopped} = String.split_at(params[key], max_length)
	Map.put(params, key, value)
	else
	params
	end
	end

	defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params

	defp fix_follower_address(%{nickname: nickname} = params),
	do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))

	defp fix_follower_address(params), do: params

	def remote_user_changeset(struct \\ %User{local: false}, params) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)

	name =
	case params[:name] do
	name when is_binary(name) and byte_size(name) > 0 -> name
	_ -> params[:nickname]
	end

	params =
	params
	\|> Map.put(:name, name)
	\|> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
	\|> truncate_if_exists(:name, name_limit)
	\|> truncate_if_exists(:bio, bio_limit)
	\|> truncate_fields_param()
	\|> fix_follower_address()

	struct
	\|> cast(
	params,
	[
	:bio,
	:name,
	:emoji,
	:ap_id,
	:inbox,
	:shared_inbox,
	:nickname,
	:public_key,
	:avatar,
	:ap_enabled,
	:banner,
	:locked,
	:last_refreshed_at,
	:uri,
	:follower_address,
	:following_address,
	:hide_followers,
	:hide_follows,
	:hide_followers_count,
	:hide_follows_count,
	:follower_count,
	:fields,
	:following_count,
	:discoverable,
	:invisible,
	:actor_type,
	:also_known_as,
	:accepts_chat_messages
	]
	)
	\|> validate_required([:name, :ap_id])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> validate_fields(true)
	end

	def update_changeset(struct, params \\ %{}) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)

	struct
	\|> cast(
	params,
	[
	:bio,
	:raw_bio,
	:name,
	:emoji,
	:avatar,
	:public_key,
	:inbox,
	:shared_inbox,
	:locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:hide_followers_count,
	:hide_follows_count,
	:hide_favorites,
	:allow_following_move,
	:background,
	:show_role,
	:skip_thread_containment,
	:fields,
	:raw_fields,
	:pleroma_settings_store,
	:discoverable,
	:actor_type,
	:also_known_as,
	:accepts_chat_messages
	]
	)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_inclusion(:actor_type, ["Person", "Service"])
	\|> put_fields()
	\|> put_emoji()
	\|> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
	\|> put_change_if_present(:avatar, &put_upload(&1, :avatar))
	\|> put_change_if_present(:banner, &put_upload(&1, :banner))
	\|> put_change_if_present(:background, &put_upload(&1, :background))
	\|> put_change_if_present(
	:pleroma_settings_store,
	&{:ok, Map.merge(struct.pleroma_settings_store, &1)}
	)
	\|> validate_fields(false)
	end

	defp put_fields(changeset) do
	if raw_fields = get_change(changeset, :raw_fields) do
	raw_fields =
	raw_fields
	\|> Enum.filter(fn %{"name" => n} -> n != "" end)

	fields =
	raw_fields
	\|> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)

	changeset
	\|> put_change(:raw_fields, raw_fields)
	\|> put_change(:fields, fields)
	else
	changeset
	end
	end

	defp parse_fields(value) do
	value
	\|> Formatter.linkify(mentions_format: :full)
	\|> elem(0)
	end

	defp put_emoji(changeset) do
	emojified_fields = [:bio, :name, :raw_fields]

	if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
	bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
	name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))

	emoji = Map.merge(bio, name)

	emoji =
	changeset
	\|> get_field(:raw_fields)
	\|> Enum.reduce(emoji, fn x, acc ->
	Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
	end)

	put_change(changeset, :emoji, emoji)
	else
	changeset
	end
	end

	defp put_change_if_present(changeset, map_field, value_function) do
	with {:ok, value} <- fetch_change(changeset, map_field),
	{:ok, new_value} <- value_function.(value) do
	put_change(changeset, map_field, new_value)
	else
	_ -> changeset
	end
	end

	defp put_upload(value, type) do
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: type) do
	{:ok, object.data}
	end
	end

	def update_as_admin_changeset(struct, params) do
	struct
	\|> update_changeset(params)
	\|> cast(params, [:email])
	\|> delete_change(:also_known_as)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_inclusion(:actor_type, ["Person", "Service"])
	end

	@spec update_as_admin(User.t(), map()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def update_as_admin(user, params) do
	params = Map.put(params, "password_confirmation", params["password"])
	changeset = update_as_admin_changeset(user, params)

	if params["password"] do
	reset_password(user, changeset, params)
	else
	User.update_and_set_cache(changeset)
	end
	end

	def password_update_changeset(struct, params) do
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> put_password_hash()
	\|> put_change(:password_reset_pending, false)
	end

	@spec reset_password(User.t(), map()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def reset_password(%User{} = user, params) do
	reset_password(user, user, params)
	end

	def reset_password(%User{id: user_id} = user, struct, params) do
	multi =
	Multi.new()
	\|> Multi.update(:user, password_update_changeset(struct, params))
	\|> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
	\|> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))

	case Repo.transaction(multi) do
	{:ok, %{user: user} = _} -> set_cache(user)
	{:error, _, changeset, _} -> {:error, changeset}
	end
	end

	def update_password_reset_pending(user, value) do
	user
	\|> change()
	\|> put_change(:password_reset_pending, value)
	\|> update_and_set_cache()
	end

	def force_password_reset_async(user) do
	BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
	end

	@spec force_password_reset(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def force_password_reset(user), do: update_password_reset_pending(user, true)

	# Used to auto-register LDAP accounts which won't have a password hash stored locally
	def register_changeset_ldap(struct, params = %{password: password})
	when is_nil(password) do
	params = Map.put_new(params, :accepts_chat_messages, true)

	params =
	if Map.has_key?(params, :email) do
	Map.put_new(params, :email, params[:email])
	else
	params
	end

	struct
	\|> cast(params, [
	:name,
	:nickname,
	:email,
	:accepts_chat_messages
	])
	\|> validate_required([:name, :nickname])
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_address()
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)
	reason_limit = Config.get([:instance, :registration_reason_length], 500)
	params = Map.put_new(params, :accepts_chat_messages, true)

	need_confirmation? =
	if is_nil(opts[:need_confirmation]) do
	Config.get([:instance, :account_activation_required])
	else
	opts[:need_confirmation]
	end

	need_approval? =
	if is_nil(opts[:need_approval]) do
	Config.get([:instance, :account_approval_required])
	else
	opts[:need_approval]
	end

	struct
	\|> confirmation_changeset(need_confirmation: need_confirmation?)
	\|> approval_changeset(need_approval: need_approval?)
	\|> cast(params, [
	:bio,
	:raw_bio,
	:email,
	:name,
	:nickname,
	:password,
	:password_confirmation,
	:emoji,
	:accepts_chat_messages,
	:registration_reason
	])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_change(:email, fn :email, email ->
	valid? =
	Config.get([User, :email_blacklist])
	\|> Enum.all?(fn blacklisted_domain ->
	!String.ends_with?(email, ["@" <> blacklisted_domain, "." <> blacklisted_domain])
	end)

	if valid?, do: [], else: [email: "Invalid email"]
	end)
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_length(:registration_reason, max: reason_limit)
	\|> maybe_validate_required_email(opts[:external])
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_address()
	end

	def maybe_validate_required_email(changeset, true), do: changeset

	def maybe_validate_required_email(changeset, _) do
	if Config.get([:instance, :account_activation_required]) do
	validate_required(changeset, [:email])
	else
	changeset
	end
	end

	defp put_ap_id(changeset) do
	ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
	put_change(changeset, :ap_id, ap_id)
	end

	defp put_following_and_follower_address(changeset) do
	followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})

	changeset
	\|> put_change(:follower_address, followers)
	end

	defp autofollow_users(user) do
	candidates = Config.get([:instance, :autofollowed_nicknames])

	autofollowed_users =
	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()

	follow_all(user, autofollowed_users)
	end

	@doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
	def register(%Ecto.Changeset{} = changeset) do
	with {:ok, user} <- Repo.insert(changeset) do
	post_register_action(user)
	end
	end

	def post_register_action(%User{} = user) do
	with {:ok, user} <- autofollow_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- send_welcome_email(user),
	{:ok, _} <- send_welcome_message(user),
	{:ok, _} <- send_welcome_chat_message(user),
	{:ok, _} <- try_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def send_welcome_message(user) do
	if User.WelcomeMessage.enabled?() do
	User.WelcomeMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def send_welcome_chat_message(user) do
	if User.WelcomeChatMessage.enabled?() do
	User.WelcomeChatMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def send_welcome_email(%User{email: email} = user) when is_binary(email) do
	if User.WelcomeEmail.enabled?() do
	User.WelcomeEmail.send_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def send_welcome_email(_), do: {:ok, :noop}

	@spec try_send_confirmation_email(User.t()) :: {:ok, :enqueued \| :noop}
	def try_send_confirmation_email(%User{confirmation_pending: true, email: email} = user)
	when is_binary(email) do
	if Config.get([:instance, :account_activation_required]) do
	send_confirmation_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def try_send_confirmation_email(_), do: {:ok, :noop}

	@spec send_confirmation_email(Uset.t()) :: User.t()
	def send_confirmation_email(%User{} = user) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	user
	end

	def needs_update?(%User{local: true}), do: false

	def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true

	def needs_update?(%User{local: false} = user) do
	NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
	end

	def needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} \| {:error, String.t()}

	# "Locked" (self-locked) users demand explicit authorization of follow requests
	def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do
	follow(follower, followed, :follow_pending)
	end

	def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
	follow(follower, followed)
	end

	def maybe_direct_follow(%User{} = follower, %User{} = followed) do
	if not ap_enabled?(followed) do
	follow(follower, followed)
	else
	{:ok, follower}
	end
	end

	@doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
	@spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
	def follow_all(follower, followeds) do
	followeds
	\|> Enum.reject(fn followed -> blocks?(follower, followed) \|\| blocks?(followed, follower) end)
	\|> Enum.each(&follow(follower, &1, :follow_accept))

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	cond do
	followed.deactivated ->
	{:error, "Could not follow user: #{followed.nickname} is deactivated."}

	deny_follow_blocked and blocks?(followed, follower) ->
	{:error, "Could not follow user: #{followed.nickname} blocked you."}

	true ->
	FollowingRelationship.follow(follower, followed, state)

	{:ok, _} = update_follower_count(followed)

	follower
	\|> update_following_count()
	end
	end

	def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
	{:error, "Not subscribed!"}
	end

	@spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} \| {:error, String.t()}
	def unfollow(%User{} = follower, %User{} = followed) do
	case do_unfollow(follower, followed) do
	{:ok, follower, followed} ->
	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}

	error ->
	error
	end
	end

	@spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} \| {:error, String.t()}
	defp do_unfollow(%User{} = follower, %User{} = followed) do
	case get_follow_state(follower, followed) do
	state when state in [:follow_pending, :follow_accept] ->
	FollowingRelationship.unfollow(follower, followed)
	{:ok, followed} = update_follower_count(followed)

	- {:ok, follower} =
	- follower
	- \|> update_following_count()
	+ {:ok, follower} = update_following_count(follower)

	{:ok, follower, followed}

	nil ->
	{:error, "Not subscribed!"}
	end
	end

	@doc "Returns follow state as Pleroma.FollowingRelationship.State value"
	def get_follow_state(%User{} = follower, %User{} = following) do
	following_relationship = FollowingRelationship.get(follower, following)
	get_follow_state(follower, following, following_relationship)
	end

	def get_follow_state(
	%User{} = follower,
	%User{} = following,
	following_relationship
	) do
	case {following_relationship, following.local} do
	{nil, false} ->
	case Utils.fetch_latest_follow(follower, following) do
	%Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
	FollowingRelationship.state_to_enum(state)

	_ ->
	nil
	end

	{%{state: state}, _} ->
	state

	{nil, _} ->
	nil
	end
	end

	def locked?(%User{} = user) do
	user.locked \|\| false
	end

	def get_by_id(id) do
	Repo.get_by(User, id: id)
	end

	def get_by_ap_id(ap_id) do
	Repo.get_by(User, ap_id: ap_id)
	end

	def get_all_by_ap_id(ap_ids) do
	from(u in __MODULE__,
	where: u.ap_id in ^ap_ids
	)
	\|> Repo.all()
	end

	def get_all_by_ids(ids) do
	from(u in __MODULE__, where: u.id in ^ids)
	\|> Repo.all()
	end

	# This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
	# of the ap_id and the domain and tries to get that user
	def get_by_guessed_nickname(ap_id) do
	domain = URI.parse(ap_id).host
	name = List.last(String.split(ap_id, "/"))
	nickname = "#{name}@#{domain}"

	get_cached_by_nickname(nickname)
	end

	def set_cache({:ok, user}), do: set_cache(user)
	def set_cache({:error, err}), do: {:error, err}

	def set_cache(%User{} = user) do
	Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	Cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
	{:ok, user}
	end

	def update_and_set_cache(struct, params) do
	struct
	\|> update_changeset(params)
	\|> update_and_set_cache()
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	set_cache(user)
	end
	end

	def get_user_friends_ap_ids(user) do
	from(u in User.get_friends_query(user), select: u.ap_id)
	\|> Repo.all()
	end

	@spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
	def get_cached_user_friends_ap_ids(user) do
	Cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
	get_user_friends_ap_ids(user)
	end)
	end

	def invalidate_cache(user) do
	Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	Cachex.del(:user_cache, "nickname:#{user.nickname}")
	Cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
	end

	@spec get_cached_by_ap_id(String.t()) :: User.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"

	with {:ok, nil} <- Cachex.get(:user_cache, key),
	user when not is_nil(user) <- get_by_ap_id(ap_id),
	{:ok, true} <- Cachex.put(:user_cache, key, user) do
	user
	else
	{:ok, user} -> user
	nil -> nil
	end
	end

	def get_cached_by_id(id) do
	key = "id:#{id}"

	ap_id =
	Cachex.fetch!(:user_cache, key, fn _ ->
	user = get_by_id(id)

	if user do
	Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	{:commit, user.ap_id}
	else
	{:ignore, ""}
	end
	end)

	get_cached_by_ap_id(ap_id)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"

	Cachex.fetch!(:user_cache, key, fn ->
	case get_or_fetch_by_nickname(nickname) do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
	restrict_to_local = Config.get([:instance, :limit_to_local_content])

	cond do
	is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)

	restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
	get_cached_by_nickname(nickname_or_id)

	restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
	get_cached_by_nickname(nickname_or_id)

	true ->
	nil
	end
	end

	@spec get_by_nickname(String.t()) :: User.t() \| nil
	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname) \|\|
	if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
	Repo.get_by(User, nickname: local_nickname(nickname))
	end
	end

	def get_by_email(email), do: Repo.get_by(User, email: email)

	def get_by_nickname_or_email(nickname_or_email) do
	get_by_nickname(nickname_or_email) \|\| get_by_email(nickname_or_email)
	end

	def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	{:ok, user}
	else
	_e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- fetch_by_nickname(nickname) do
	{:ok, user}
	else
	_e -> {:error, "not found " <> nickname}
	end
	end
	end

	@spec get_followers_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_followers_query(%User{} = user, nil) do
	User.Query.build(%{followers: user, deactivated: false})
	end

	def get_followers_query(%User{} = user, page) do
	user
	\|> get_followers_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_followers_query(User.t()) :: Ecto.Query.t()
	def get_followers_query(%User{} = user), do: get_followers_query(user, nil)

	@spec get_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> Repo.all()
	end

	@spec get_external_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_external_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> User.Query.build(%{external: true})
	\|> Repo.all()
	end

	def get_followers_ids(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	@spec get_friends_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_friends_query(%User{} = user, nil) do
	User.Query.build(%{friends: user, deactivated: false})
	end

	def get_friends_query(%User{} = user, page) do
	user
	\|> get_friends_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_friends_query(User.t()) :: Ecto.Query.t()
	def get_friends_query(%User{} = user), do: get_friends_query(user, nil)

	def get_friends(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

	def get_friends_ap_ids(%User{} = user) do
	user
	\|> get_friends_query(nil)
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end

	def get_friends_ids(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], inc: [note_count: 1])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def decrease_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	note_count: fragment("greatest(0, note_count - 1)")
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def update_note_count(%User{} = user, note_count \\ nil) do
	note_count =
	note_count \|\|
	from(
	a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)
	)
	\|> Repo.one()

	user
	\|> cast(%{note_count: note_count}, [:note_count])
	\|> update_and_set_cache()
	end

	@spec maybe_fetch_follow_information(User.t()) :: User.t()
	def maybe_fetch_follow_information(user) do
	with {:ok, user} <- fetch_follow_information(user) do
	user
	else
	e ->
	Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	user
	\|> follow_information_changeset(info)
	\|> update_and_set_cache()
	end
	end

	defp follow_information_changeset(user, params) do
	user
	\|> cast(params, [
	:hide_followers,
	:hide_follows,
	:follower_count,
	:following_count,
	:hide_followers_count,
	:hide_follows_count
	])
	end

	@spec update_follower_count(User.t()) :: {:ok, User.t()}
	def update_follower_count(%User{} = user) do
	if user.local or !Config.get([:instance, :external_user_synchronization]) do
	follower_count = FollowingRelationship.follower_count(user)

	user
	\|> follow_information_changeset(%{follower_count: follower_count})
	\|> update_and_set_cache
	else
	{:ok, maybe_fetch_follow_information(user)}
	end
	end

	@spec update_following_count(User.t()) :: {:ok, User.t()}
	def update_following_count(%User{local: false} = user) do
	if Config.get([:instance, :external_user_synchronization]) do
	{:ok, maybe_fetch_follow_information(user)}
	else
	{:ok, user}
	end
	end

	def update_following_count(%User{local: true} = user) do
	following_count = FollowingRelationship.following_count(user)

	user
	\|> follow_information_changeset(%{following_count: following_count})
	\|> update_and_set_cache()
	end

	def set_unread_conversation_count(%User{local: true} = user) do
	unread_query = Participation.unread_conversation_count_for_user(user)

	User
	\|> join(:inner, [u], p in subquery(unread_query))
	\|> update([u, p],
	set: [unread_conversation_count: p.count]
	)
	\|> where([u], u.id == ^user.id)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def set_unread_conversation_count(user), do: {:ok, user}

	def increment_unread_conversation_count(conversation, %User{local: true} = user) do
	unread_query =
	Participation.unread_conversation_count_for_user(user)
	\|> where([p], p.conversation_id == ^conversation.id)

	User
	\|> join(:inner, [u], p in subquery(unread_query))
	\|> update([u, p],
	inc: [unread_conversation_count: 1]
	)
	\|> where([u], u.id == ^user.id)
	\|> where([u, p], p.count == 0)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def increment_unread_conversation_count(_, user), do: {:ok, user}

	@spec get_users_from_set([String.t()], keyword()) :: [User.t()]
	def get_users_from_set(ap_ids, opts \\ []) do
	local_only = Keyword.get(opts, :local_only, true)
	criteria = %{ap_id: ap_ids, deactivated: false}
	criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria

	User.Query.build(criteria)
	\|> Repo.all()
	end

	@spec get_recipients_from_activity(Activity.t()) :: [User.t()]
	def get_recipients_from_activity(%Activity{recipients: to, actor: actor}) do
	to = [actor \| to]

	query = User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})

	query
	\|> Repo.all()
	end

	@spec mute(User.t(), User.t(), boolean()) ::
	{:ok, list(UserRelationship.t())} \| {:error, String.t()}
	def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
	add_to_mutes(muter, mutee, notifications?)
	end

	def unmute(%User{} = muter, %User{} = mutee) do
	remove_from_mutes(muter, mutee)
	end

	def subscribe(%User{} = subscriber, %User{} = target) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	if blocks?(target, subscriber) and deny_follow_blocked do
	{:error, "Could not subscribe: #{target.nickname} is blocking you"}
	else
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.create_inverse_subscription(target, subscriber)
	end
	end

	def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
	with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
	subscribe(subscriber, subscribee)
	end
	end

	def unsubscribe(%User{} = unsubscriber, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.delete_inverse_subscription(target, unsubscriber)
	end

	def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unsubscribe(unsubscriber, user)
	end
	end

	def block(%User{} = blocker, %User{} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

	# clear any requested follows as well
	blocked =
	case CommonAPI.reject_follow_request(blocked, blocker) do
	{:ok, %User{} = updated_blocked} -> updated_blocked
	nil -> blocked
	end

	unsubscribe(blocked, blocker)

	unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
	if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)

	{:ok, blocker} = update_follower_count(blocker)
	{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
	add_to_block(blocker, blocked)
	end

	# helper to handle the block given only an actor's AP id
	def block(%User{} = blocker, %{ap_id: ap_id}) do
	block(blocker, get_cached_by_ap_id(ap_id))
	end

	def unblock(%User{} = blocker, %User{} = blocked) do
	remove_from_block(blocker, blocked)
	end

	# helper to handle the block given only an actor's AP id
	def unblock(%User{} = blocker, %{ap_id: ap_id}) do
	unblock(blocker, get_cached_by_ap_id(ap_id))
	end

	def mutes?(nil, _), do: false
	def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)

	def mutes_user?(%User{} = user, %User{} = target) do
	UserRelationship.mute_exists?(user, target)
	end

	@spec muted_notifications?(User.t() \| nil, User.t() \| map()) :: boolean()
	def muted_notifications?(nil, _), do: false

	def muted_notifications?(%User{} = user, %User{} = target),
	do: UserRelationship.notification_mute_exists?(user, target)

	def blocks?(nil, _), do: false

	def blocks?(%User{} = user, %User{} = target) do
	blocks_user?(user, target) \|\|
	(blocks_domain?(user, target) and not User.following?(user, target))
	end

	def blocks_user?(%User{} = user, %User{} = target) do
	UserRelationship.block_exists?(user, target)
	end

	def blocks_user?(_, _), do: false

	def blocks_domain?(%User{} = user, %User{} = target) do
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
	%{host: host} = URI.parse(target.ap_id)
	Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
	end

	def blocks_domain?(_, _), do: false

	def subscribed_to?(%User{} = user, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.inverse_subscription_exists?(target, user)
	end

	def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
	with %User{} = target <- get_cached_by_ap_id(ap_id) do
	subscribed_to?(user, target)
	end
	end

	@doc """
	Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
	E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
	"""
	@spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
	def outgoing_relationships_ap_ids(_user, []), do: %{}

	def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}

	def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
	when is_list(relationship_types) do
	db_result =
	user
	\|> assoc(:outgoing_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :target))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
	\|> group_by([user_rel, u], user_rel.relationship_type)
	\|> Repo.all()
	\|> Enum.into(%{}, fn [k, v] -> {k, v} end)

	Enum.into(
	relationship_types,
	%{},
	fn rel_type -> {rel_type, db_result[rel_type] \|\| []} end
	)
	end

	def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)

	def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
	when is_list(relationship_types) do
	user
	\|> assoc(:incoming_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :source))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> maybe_filter_on_ap_id(ap_ids)
	\|> select([user_rel, u], u.ap_id)
	\|> distinct(true)
	\|> Repo.all()
	end

	defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
	where(query, [user_rel, u], u.ap_id in ^ap_ids)
	end

	defp maybe_filter_on_ap_id(query, _ap_ids), do: query

	def deactivate_async(user, status \\ true) do
	BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
	end

	def deactivate(user, status \\ true)

	def deactivate(users, status) when is_list(users) do
	Repo.transaction(fn ->
	for user <- users, do: deactivate(user, status)
	end)
	end

	def deactivate(%User{} = user, status) do
	with {:ok, user} <- set_activation_status(user, status) do
	user
	\|> get_followers()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&set_cache(update_following_count(&1)))

	# Only update local user counts, remote will be update during the next pull.
	user
	\|> get_friends()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&do_unfollow(user, &1))

	{:ok, user}
	end
	end

	def approve(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- approve(user), do: user
	end)
	end)
	end

	def approve(%User{} = user) do
	change(user, approval_pending: false)
	\|> update_and_set_cache()
	end

	def update_notification_settings(%User{} = user, settings) do
	user
	\|> cast(%{notification_settings: settings}, [])
	\|> cast_embed(:notification_settings)
	\|> validate_required([:notification_settings])
	\|> update_and_set_cache()
	end

	@spec purge_user_changeset(User.t()) :: Changeset.t()
	def purge_user_changeset(user) do
	# "Right to be forgotten"
	# https://gdpr.eu/right-to-be-forgotten/
	change(user, %{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	keys: nil,
	public_key: nil,
	avatar: %{},
	tags: [],
	last_refreshed_at: nil,
	last_digest_emailed_at: nil,
	banner: %{},
	background: %{},
	note_count: 0,
	follower_count: 0,
	following_count: 0,
	locked: false,
	confirmation_pending: false,
	password_reset_pending: false,
	approval_pending: false,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	deactivated: true,
	ap_enabled: false,
	is_moderator: false,
	is_admin: false,
	mastofe_settings: nil,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	discoverable: false,
	also_known_as: []
	})
	end

	def delete(users) when is_list(users) do
	for user <- users, do: delete(user)
	end

	def delete(%User{} = user) do
	BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
	end

	defp delete_and_invalidate_cache(%User{} = user) do
	invalidate_cache(user)
	Repo.delete(user)
	end

	defp delete_or_deactivate(%User{local: false} = user), do: delete_and_invalidate_cache(user)

	defp delete_or_deactivate(%User{local: true} = user) do
	status = account_status(user)

	case status do
	:confirmation_pending ->
	delete_and_invalidate_cache(user)

	:approval_pending ->
	delete_and_invalidate_cache(user)

	_ ->
	user
	\|> purge_user_changeset()
	\|> update_and_set_cache()
	end
	end

	def perform(:force_password_reset, user), do: force_password_reset(user)

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:delete, %User{} = user) do
	# Remove all relationships
	user
	\|> get_followers()
	\|> Enum.each(fn follower ->
	ActivityPub.unfollow(follower, user)
	unfollow(follower, user)
	end)

	user
	\|> get_friends()
	\|> Enum.each(fn followed ->
	ActivityPub.unfollow(user, followed)
	unfollow(user, followed)
	end)

	delete_user_activities(user)
	delete_notifications_from_user_activities(user)

	delete_outgoing_pending_follow_requests(user)

	delete_or_deactivate(user)
	end

	def perform(:deactivate_async, user, status), do: deactivate(user, status)

	@spec external_users_query() :: Ecto.Query.t()
	def external_users_query do
	User.Query.build(%{
	external: true,
	active: true,
	order_by: :id
	})
	end

	@spec external_users(keyword()) :: [User.t()]
	def external_users(opts \\ []) do
	query =
	external_users_query()
	\|> select([u], struct(u, [:id, :ap_id]))

	query =
	if opts[:max_id],
	do: where(query, [u], u.id > ^opts[:max_id]),
	else: query

	query =
	if opts[:limit],
	do: limit(query, ^opts[:limit]),
	else: query

	Repo.all(query)
	end

	def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
	Notification
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> where([n, a], fragment("? = ?", a.actor, ^ap_id))
	\|> Repo.delete_all()
	end

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.chunk_stream(50, :batches)
	\|> Stream.each(fn activities ->
	Enum.each(activities, fn activity -> delete_activity(activity, user) end)
	end)
	\|> Stream.run()
	end

	defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
	with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
	{:ok, delete_data, _} <- Builder.delete(user, object) do
	Pipeline.common_pipeline(delete_data, local: user.local)
	else
	{:find_object, nil} ->
	# We have the create activity, but not the object, it was probably pruned.
	# Insert a tombstone and try again
	with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	delete_activity(activity, user)
	end

	e ->
	Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
	Logger.error("Error: #{inspect(e)}")
	end
	end

	defp delete_activity(%{data: %{"type" => type}} = activity, user)
	when type in ["Like", "Announce"] do
	{:ok, undo, _} = Builder.undo(user, activity)
	Pipeline.common_pipeline(undo, local: user.local)
	end

	defp delete_activity(_activity, _user), do: "Doing nothing"

	defp delete_outgoing_pending_follow_requests(user) do
	user
	\|> FollowingRelationship.outgoing_pending_follow_requests_query()
	\|> Repo.delete_all()
	end

	def html_filter_policy(%User{no_rich_text: true}) do
	Pleroma.HTML.Scrubber.TwitterText
	end

	def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])

	def fetch_by_ap_id(ap_id, opts \\ []), do: ActivityPub.make_user_from_ap_id(ap_id, opts)

	def get_or_fetch_by_ap_id(ap_id, opts \\ []) do
	cached_user = get_cached_by_ap_id(ap_id)

	maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id, opts)

	case {cached_user, maybe_fetched_user} do
	{_, {:ok, %User{} = user}} ->
	{:ok, user}

	{%User{} = user, _} ->
	{:ok, user}

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

	@doc """
	Creates an internal service actor by URI if missing.
	Optionally takes nickname for addressing.
	"""
	@spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() \| nil
	def get_or_create_service_actor_by_ap_id(uri, nickname) do
	{_, user} =
	case get_cached_by_ap_id(uri) do
	nil ->
	with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
	Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
	{:error, nil}
	end

	%User{invisible: false} = user ->
	set_invisible(user)

	user ->
	{:ok, user}
	end

	user
	end

	@spec set_invisible(User.t()) :: {:ok, User.t()}
	defp set_invisible(user) do
	user
	\|> change(%{invisible: true})
	\|> update_and_set_cache()
	end

	@spec create_service_actor(String.t(), String.t()) ::
	{:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	defp create_service_actor(uri, nickname) do
	%User{
	invisible: true,
	local: true,
	ap_id: uri,
	nickname: nickname,
	follower_address: uri <> "/followers"
	}
	\|> change
	\|> unique_constraint(:nickname)
	\|> Repo.insert()
	\|> set_cache()
	end

	def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
	key =
	public_key_pem
	\|> :public_key.pem_decode()
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

	def public_key(_), do: {:error, "key not found"}

	def get_public_key_for_ap_id(ap_id, opts \\ []) do
	with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id, opts),
	{:ok, public_key} <- public_key(user) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

	def ap_enabled?(%User{local: true}), do: true
	def ap_enabled?(%User{ap_enabled: ap_enabled}), do: ap_enabled
	def ap_enabled?(_), do: false

	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

	# wait a period of time and return newest version of the User structs
	# this is because we have synchronous follow APIs and need to simulate them
	# with an async handshake
	def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
	with %User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
	with :ok <- :timer.sleep(timeout),
	%User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def parse_bio(bio) when is_binary(bio) and bio != "" do
	bio
	\|> CommonUtils.format_input("text/plain", mentions_format: :full)
	\|> elem(0)
	end

	def parse_bio(_), do: ""

	def parse_bio(bio, user) when is_binary(bio) and bio != "" do
	# TODO: get profile URLs other than user.ap_id
	profile_urls = [user.ap_id]

	bio
	\|> CommonUtils.format_input("text/plain",
	mentions_format: :full,
	rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
	)
	\|> elem(0)
	end

	def parse_bio(_, _), do: ""

	def tag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
	end)
	end

	def tag(nickname, tags) when is_binary(nickname),
	do: tag(get_by_nickname(nickname), tags)

	def tag(%User{} = user, tags),
	do: update_tags(user, Enum.uniq((user.tags \|\| []) ++ normalize_tags(tags)))

	def untag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
	end)
	end

	def untag(nickname, tags) when is_binary(nickname),
	do: untag(get_by_nickname(nickname), tags)

	def untag(%User{} = user, tags),
	do: update_tags(user, (user.tags \|\| []) -- normalize_tags(tags))

	defp update_tags(%User{} = user, new_tags) do
	{:ok, updated_user} =
	user
	\|> change(%{tags: new_tags})
	\|> update_and_set_cache()

	updated_user
	end

	defp normalize_tags(tags) do
	[tags]
	\|> List.flatten()
	\|> Enum.map(&String.downcase/1)
	end

	defp local_nickname_regex do
	if Config.get([:instance, :extended_nickname_format]) do
	@extended_local_nickname_regex
	else
	@strict_local_nickname_regex
	end
	end

	def local_nickname(nickname_or_mention) do
	nickname_or_mention
	\|> full_nickname()
	\|> String.split("@")
	\|> hd()
	end

	def full_nickname(nickname_or_mention),
	do: String.trim_leading(nickname_or_mention, "@")

	def error_user(ap_id) do
	%User{
	name: ap_id,
	ap_id: ap_id,
	nickname: "erroruser@example.com",
	inserted_at: NaiveDateTime.utc_now()
	}
	end

	@spec all_superusers() :: [User.t()]
	def all_superusers do
	User.Query.build(%{super_users: true, local: true, deactivated: false})
	\|> Repo.all()
	end

	def muting_reblogs?(%User{} = user, %User{} = target) do
	UserRelationship.reblog_mute_exists?(user, target)
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	not muting_reblogs?(user, target)
	end

	@doc """
	The function returns a query to get users with no activity for given interval of days.
	Inactive users are those who didn't read any notification, or had any activity where
	the user is the activity's actor, during `inactivity_threshold` days.
	Deactivated users will not appear in this list.

	## Examples

	iex> Pleroma.User.list_inactive_users()
	%Ecto.Query{}
	"""
	@spec list_inactive_users_query(integer()) :: Ecto.Query.t()
	def list_inactive_users_query(inactivity_threshold \\ 7) do
	negative_inactivity_threshold = -inactivity_threshold
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	# Subqueries are not supported in `where` clauses, join gets too complicated.
	has_read_notifications =
	from(n in Pleroma.Notification,
	where: n.seen == true,
	group_by: n.id,
	having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
	select: n.user_id
	)
	\|> Pleroma.Repo.all()

	from(u in Pleroma.User,
	left_join: a in Pleroma.Activity,
	on: u.ap_id == a.actor,
	where: not is_nil(u.nickname),
	where: u.deactivated != ^true,
	where: u.id not in ^has_read_notifications,
	group_by: u.id,
	having:
	max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
	is_nil(max(a.inserted_at))
	)
	end

	@doc """
	Enable or disable email notifications for user

	## Examples

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
	Pleroma.User{email_notifications: %{"digest" => true}}

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
	Pleroma.User{email_notifications: %{"digest" => false}}
	"""
	@spec switch_email_notifications(t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, Ecto.Changeset.t()}
	def switch_email_notifications(user, type, status) do
	User.update_email_notifications(user, %{type => status})
	end

	@doc """
	Set `last_digest_emailed_at` value for the user to current time
	"""
	@spec touch_last_digest_emailed_at(t()) :: t()
	def touch_last_digest_emailed_at(user) do
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	{:ok, updated_user} =
	user
	\|> change(%{last_digest_emailed_at: now})
	\|> update_and_set_cache()

	updated_user
	end

	@spec toggle_confirmation(User.t()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def toggle_confirmation(%User{} = user) do
	user
	\|> confirmation_changeset(need_confirmation: !user.confirmation_pending)
	\|> update_and_set_cache()
	end

	@spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} \| {:error, Changeset.t()}]
	def toggle_confirmation(users) do
	Enum.map(users, &toggle_confirmation/1)
	end

	@spec need_confirmation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def need_confirmation(%User{} = user, bool) do
	user
	\|> confirmation_changeset(need_confirmation: bool)
	\|> update_and_set_cache()
	end

	def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
	mascot
	end

	def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
	# use instance-default
	config = Config.get([:assets, :mascots])
	default_mascot = Config.get([:assets, :default_mascot])
	mascot = Keyword.get(config, default_mascot)

	%{
	"id" => "default-mascot",
	"url" => mascot[:url],
	"preview_url" => mascot[:url],
	"pleroma" => %{
	"mime_type" => mascot[:mime_type]
	}
	}
	end

	def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}

	def ensure_keys_present(%User{} = user) do
	with {:ok, pem} <- Keys.generate_rsa_pem() do
	user
	\|> cast(%{keys: pem}, [:keys])
	\|> validate_required([:keys])
	\|> update_and_set_cache()
	end
	end

	def get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	select: u.ap_id
	)
	\|> Repo.all()
	end

	defp put_password_hash(
	%Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
	) do
	change(changeset, password_hash: Pbkdf2.hash_pwd_salt(password))
	end

	defp put_password_hash(changeset), do: changeset

	def is_internal_user?(%User{nickname: nil}), do: true
	def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
	def is_internal_user?(_), do: false

	# A hack because user delete activities have a fake id for whatever reason
	# TODO: Get rid of this
	def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []

	def get_delivered_users_by_object_id(object_id) do
	from(u in User,
	inner_join: delivery in assoc(u, :deliveries),
	where: delivery.object_id == ^object_id
	)
	\|> Repo.all()
	end

	def change_email(user, email) do
	user
	\|> cast(%{email: email}, [:email])
	\|> validate_required([:email])
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> update_and_set_cache()
	end

	# Internal function; public one is `deactivate/2`
	defp set_activation_status(user, deactivated) do
	user
	\|> cast(%{deactivated: deactivated}, [:deactivated])
	\|> update_and_set_cache()
	end

	def update_banner(user, banner) do
	user
	\|> cast(%{banner: banner}, [:banner])
	\|> update_and_set_cache()
	end

	def update_background(user, background) do
	user
	\|> cast(%{background: background}, [:background])
	\|> update_and_set_cache()
	end

	def roles(%{is_moderator: is_moderator, is_admin: is_admin}) do
	%{
	admin: is_admin,
	moderator: is_moderator
	}
	end

	def validate_fields(changeset, remote? \\ false) do
	limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
	limit = Config.get([:instance, limit_name], 0)

	changeset
	\|> validate_length(:fields, max: limit)
	\|> validate_change(:fields, fn :fields, fields ->
	if Enum.all?(fields, &valid_field?/1) do
	[]
	else
	[fields: "invalid"]
	end
	end)
	end

	defp valid_field?(%{"name" => name, "value" => value}) do
	name_limit = Config.get([:instance, :account_field_name_length], 255)
	value_limit = Config.get([:instance, :account_field_value_length], 255)

	is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
	String.length(value) <= value_limit
	end

	defp valid_field?(_), do: false

	defp truncate_field(%{"name" => name, "value" => value}) do
	{name, _chopped} =
	String.split_at(name, Config.get([:instance, :account_field_name_length], 255))

	{value, _chopped} =
	String.split_at(value, Config.get([:instance, :account_field_value_length], 255))

	%{"name" => name, "value" => value}
	end

	def admin_api_update(user, params) do
	user
	\|> cast(params, [
	:is_moderator,
	:is_admin,
	:show_role
	])
	\|> update_and_set_cache()
	end

	@doc "Signs user out of all applications"
	def global_sign_out(user) do
	OAuth.Authorization.delete_user_authorizations(user)
	OAuth.Token.delete_user_tokens(user)
	end

	def mascot_update(user, url) do
	user
	\|> cast(%{mascot: url}, [:mascot])
	\|> validate_required([:mascot])
	\|> update_and_set_cache()
	end

	def mastodon_settings_update(user, settings) do
	user
	\|> cast(%{mastofe_settings: settings}, [:mastofe_settings])
	\|> validate_required([:mastofe_settings])
	\|> update_and_set_cache()
	end

	@spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
	def confirmation_changeset(user, need_confirmation: need_confirmation?) do
	params =
	if need_confirmation? do
	%{
	confirmation_pending: true,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	}
	else
	%{
	confirmation_pending: false,
	confirmation_token: nil
	}
	end

	cast(user, params, [:confirmation_pending, :confirmation_token])
	end

	@spec approval_changeset(User.t(), keyword()) :: Changeset.t()
	def approval_changeset(user, need_approval: need_approval?) do
	params = if need_approval?, do: %{approval_pending: true}, else: %{approval_pending: false}
	cast(user, params, [:approval_pending])
	end

	def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
	if id not in user.pinned_activities do
	max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)
	params = %{pinned_activities: user.pinned_activities ++ [id]}

	# if pinned activity was scheduled for deletion, we remove job
	if expiration = Pleroma.Workers.PurgeExpiredActivity.get_expiration(id) do
	Oban.cancel_job(expiration.id)
	end

	user
	\|> cast(params, [:pinned_activities])
	\|> validate_length(:pinned_activities,
	max: max_pinned_statuses,
	message: "You have already pinned the maximum number of statuses"
	)
	else
	change(user)
	end
	\|> update_and_set_cache()
	end

	def remove_pinnned_activity(user, %Pleroma.Activity{id: id, data: data}) do
	params = %{pinned_activities: List.delete(user.pinned_activities, id)}

	# if pinned activity was scheduled for deletion, we reschedule it for deletion
	if data["expires_at"] do
	- {:ok, expires_at, _} = DateTime.from_iso8601(data["expires_at"])
	+ # MRF.ActivityExpirationPolicy used UTC timestamps for expires_at in original implementation
	+ {:ok, expires_at} =
	+ data["expires_at"] \|> Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime.cast()

	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: id,
	expires_at: expires_at
	})
	end

	user
	\|> cast(params, [:pinned_activities])
	\|> update_and_set_cache()
	end

	def update_email_notifications(user, settings) do
	email_notifications =
	user.email_notifications
	\|> Map.merge(settings)
	\|> Map.take(["digest"])

	params = %{email_notifications: email_notifications}
	fields = [:email_notifications]

	user
	\|> cast(params, fields)
	\|> validate_required(fields)
	\|> update_and_set_cache()
	end

	defp set_domain_blocks(user, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

	user
	\|> cast(params, [:domain_blocks])
	\|> validate_required([:domain_blocks])
	\|> update_and_set_cache()
	end

	def block_domain(user, domain_blocked) do
	set_domain_blocks(user, Enum.uniq([domain_blocked \| user.domain_blocks]))
	end

	def unblock_domain(user, domain_blocked) do
	set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:error, Ecto.Changeset.t()}
	defp add_to_block(%User{} = user, %User{} = blocked) do
	UserRelationship.create_block(user, blocked)
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:ok, nil} \| {:error, Ecto.Changeset.t()}
	defp remove_from_block(%User{} = user, %User{} = blocked) do
	UserRelationship.delete_block(user, blocked)
	end

	defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
	with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
	{:ok, user_notification_mute} <-
	(notifications? && UserRelationship.create_notification_mute(user, muted_user)) \|\|
	{:ok, nil} do
	{:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
	end
	end

	defp remove_from_mutes(user, %User{} = muted_user) do
	with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
	{:ok, user_notification_mute} <-
	UserRelationship.delete_notification_mute(user, muted_user) do
	{:ok, [user_mute, user_notification_mute]}
	end
	end

	def set_invisible(user, invisible) do
	params = %{invisible: invisible}

	user
	\|> cast(params, [:invisible])
	\|> validate_required([:invisible])
	\|> update_and_set_cache()
	end

	def sanitize_html(%User{} = user) do
	sanitize_html(user, nil)
	end

	# User data that mastodon isn't filtering (treated as plaintext):
	# - field name
	# - display name
	def sanitize_html(%User{} = user, filter) do
	fields =
	Enum.map(user.fields, fn %{"name" => name, "value" => value} ->
	%{
	"name" => name,
	"value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
	}
	end)

	user
	\|> Map.put(:bio, HTML.filter_tags(user.bio, filter))
	\|> Map.put(:fields, fields)
	end
	end
	diff --git a/lib/pleroma/user/search.ex b/lib/pleroma/user/search.ex
	index 03f2c552f..35a828008 100644
	--- a/lib/pleroma/user/search.ex
	+++ b/lib/pleroma/user/search.ex
	@@ -1,265 +1,266 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.Search do
	alias Pleroma.EctoType.ActivityPub.ObjectValidators.Uri, as: UriType
	alias Pleroma.Pagination
	alias Pleroma.User

	import Ecto.Query

	@limit 20

	def search(query_string, opts \\ []) do
	resolve = Keyword.get(opts, :resolve, false)
	following = Keyword.get(opts, :following, false)
	result_limit = Keyword.get(opts, :limit, @limit)
	offset = Keyword.get(opts, :offset, 0)

	for_user = Keyword.get(opts, :for_user)

	query_string = format_query(query_string)

	# If this returns anything, it should bounce to the top
	maybe_resolved = maybe_resolve(resolve, for_user, query_string)

	top_user_ids =
	[]
	\|> maybe_add_resolved(maybe_resolved)
	\|> maybe_add_ap_id_match(query_string)
	\|> maybe_add_uri_match(query_string)

	results =
	query_string
	\|> search_query(for_user, following, top_user_ids)
	\|> Pagination.fetch_paginated(%{"offset" => offset, "limit" => result_limit}, :offset)

	results
	end

	defp maybe_add_resolved(list, {:ok, %User{} = user}) do
	[user.id \| list]
	end

	defp maybe_add_resolved(list, _), do: list

	defp maybe_add_ap_id_match(list, query) do
	if user = User.get_cached_by_ap_id(query) do
	[user.id \| list]
	else
	list
	end
	end

	defp maybe_add_uri_match(list, query) do
	with {:ok, query} <- UriType.cast(query),
	- %User{} = user <- Pleroma.Repo.get_by(User, uri: query) do
	- [user.id \| list]
	+ q = from(u in User, where: u.uri == ^query, select: u.id),
	+ users = Pleroma.Repo.all(q) do
	+ users ++ list
	else
	_ -> list
	end
	end

	defp format_query(query_string) do
	# Strip the beginning @ off if there is a query
	query_string = String.trim_leading(query_string, "@")

	with [name, domain] <- String.split(query_string, "@") do
	encoded_domain =
	domain
	\|> String.replace(~r/[!-\-\|@\|[-`\|{-~\|\/\|:\|\s]+/, "")
	\|> String.to_charlist()
	\|> :idna.encode()
	\|> to_string()

	name <> "@" <> encoded_domain
	else
	_ -> query_string
	end
	end

	defp search_query(query_string, for_user, following, top_user_ids) do
	for_user
	\|> base_query(following)
	\|> filter_blocked_user(for_user)
	\|> filter_invisible_users()
	\|> filter_discoverable_users()
	\|> filter_internal_users()
	\|> filter_blocked_domains(for_user)
	\|> fts_search(query_string)
	\|> select_top_users(top_user_ids)
	\|> trigram_rank(query_string)
	\|> boost_search_rank(for_user, top_user_ids)
	\|> subquery()
	\|> order_by(desc: :search_rank)
	\|> maybe_restrict_local(for_user)
	end

	defp select_top_users(query, top_user_ids) do
	from(u in query,
	or_where: u.id in ^top_user_ids
	)
	end

	defp fts_search(query, query_string) do
	query_string = to_tsquery(query_string)

	from(
	u in query,
	where:
	fragment(
	# The fragment must _exactly_ match `users_fts_index`, otherwise the index won't work
	"""
	(
	setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') \|\|
	setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')
	) @@ to_tsquery('simple', ?)
	""",
	u.nickname,
	u.name,
	^query_string
	)
	)
	end

	defp to_tsquery(query_string) do
	String.trim_trailing(query_string, "@" <> local_domain())
	\|> String.replace(~r/[!-\/\|@\|[-`\|{-~\|:-?]+/, " ")
	\|> String.trim()
	\|> String.split()
	\|> Enum.map(&(&1 <> ":*"))
	\|> Enum.join(" \| ")
	end

	# Considers nickname match, localized nickname match, name match; preferences nickname match
	defp trigram_rank(query, query_string) do
	from(
	u in query,
	select_merge: %{
	search_rank:
	fragment(
	"""
	similarity(?, ?) +
	similarity(?, regexp_replace(?, '@.+', '')) +
	similarity(?, trim(coalesce(?, '')))
	""",
	^query_string,
	u.nickname,
	^query_string,
	u.nickname,
	^query_string,
	u.name
	)
	}
	)
	end

	defp base_query(%User{} = user, true), do: User.get_friends_query(user)
	defp base_query(_user, _following), do: User

	defp filter_invisible_users(query) do
	from(q in query, where: q.invisible == false)
	end

	defp filter_discoverable_users(query) do
	from(q in query, where: q.discoverable == true)
	end

	defp filter_internal_users(query) do
	from(q in query, where: q.actor_type != "Application")
	end

	defp filter_blocked_user(query, %User{} = blocker) do
	query
	\|> join(:left, [u], b in Pleroma.UserRelationship,
	as: :blocks,
	on: b.relationship_type == ^:block and b.source_id == ^blocker.id and u.id == b.target_id
	)
	\|> where([blocks: b], is_nil(b.target_id))
	end

	defp filter_blocked_user(query, _), do: query

	defp filter_blocked_domains(query, %User{domain_blocks: domain_blocks})
	when length(domain_blocks) > 0 do
	domains = Enum.join(domain_blocks, ",")

	from(
	q in query,
	where: fragment("substring(ap_id from '.://([^/])') NOT IN (?)", ^domains)
	)
	end

	defp filter_blocked_domains(query, _), do: query

	defp maybe_resolve(true, user, query) do
	case {limit(), user} do
	{:all, _} -> :noop
	{:unauthenticated, %User{}} -> User.get_or_fetch(query)
	{:unauthenticated, _} -> :noop
	{false, _} -> User.get_or_fetch(query)
	end
	end

	defp maybe_resolve(_, _, _), do: :noop

	defp maybe_restrict_local(q, user) do
	case {limit(), user} do
	{:all, _} -> restrict_local(q)
	{:unauthenticated, %User{}} -> q
	{:unauthenticated, _} -> restrict_local(q)
	{false, _} -> q
	end
	end

	defp limit, do: Pleroma.Config.get([:instance, :limit_to_local_content], :unauthenticated)

	defp restrict_local(q), do: where(q, [u], u.local == true)

	defp local_domain, do: Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])

	defp boost_search_rank(query, %User{} = for_user, top_user_ids) do
	friends_ids = User.get_friends_ids(for_user)
	followers_ids = User.get_followers_ids(for_user)

	from(u in subquery(query),
	select_merge: %{
	search_rank:
	fragment(
	"""
	CASE WHEN (?) THEN (?) * 1.5
	WHEN (?) THEN (?) * 1.3
	WHEN (?) THEN (?) * 1.1
	WHEN (?) THEN 9001
	ELSE (?) END
	""",
	u.id in ^friends_ids and u.id in ^followers_ids,
	u.search_rank,
	u.id in ^friends_ids,
	u.search_rank,
	u.id in ^followers_ids,
	u.search_rank,
	u.id in ^top_user_ids,
	u.search_rank
	)
	}
	)
	end

	defp boost_search_rank(query, _for_user, top_user_ids) do
	from(u in subquery(query),
	select_merge: %{
	search_rank:
	fragment(
	"""
	CASE WHEN (?) THEN 9001
	ELSE (?) END
	""",
	u.id in ^top_user_ids,
	u.search_rank
	)
	}
	)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index aacd58d03..eb44cffec 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1449 +1,1459 @@
	# 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.Filter
	alias Pleroma.Maps
	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.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

	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(nil), do: true

	defp check_actor_is_active(actor) when is_binary(actor) do
	case User.get_cached_by_ap_id(actor) do
	%User{deactivated: deactivated} -> not deactivated
	_ -> false
	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

	defp 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

	defp increase_replies_count_if_reply(_create_data), do: :noop

	@object_types ~w[ChatMessage Question Answer Audio Video Event Article]
	@spec persist(map(), keyword()) :: {:ok, Activity.t() \| Object.t()}
	def persist(%{"type" => type} = object, meta) when type in @object_types do
	with {:ok, object} <- Object.create(object) do
	{:ok, object, meta}
	end
	end

	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"]
	}),
	# TODO: add tests for expired activities, when Note type will be supported in new pipeline
	{:ok, _} <- maybe_create_activity_expiration(activity) 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} <- {:actor_check, bypass_actor_check \|\| check_actor_is_active(map["actor"])},
	{_, true} <- {:remote_limit_pass, 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),
	{:ok, activity} <- insert_activity_with_expiration(map, local, recipients) do
	# Splice in the child object if we have one.
	activity = Maps.put_if_present(activity, :object, object)

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

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

	{:actor_check, _} ->
	{:error, false}

	{:containment, _} = error ->
	error

	{:error, _} = error ->
	error

	{: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}

	{:remote_limit_pass, _} ->
	{:error, :remote_limit}

	{:reject, _} = e ->
	{:error, e}
	end
	end

	defp insert_activity_with_expiration(data, local, recipients) do
	struct = %Activity{
	data: data,
	local: local,
	actor: data["actor"],
	recipients: recipients
	}

	with {:ok, activity} <- Repo.insert(struct) do
	maybe_create_activity_expiration(activity)
	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 maybe_create_activity_expiration(
	%{data: %{"expires_at" => %DateTime{} = expires_at}} = activity
	) do
	with {:ok, _job} <-
	Pleroma.Workers.PurgeExpiredActivity.enqueue(%{
	activity_id: activity.id,
	expires_at: expires_at
	}) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(activity), do: {:ok, activity}

	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) do
	Participation.mark_as_read(user, conversation)
	{: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) do
	conversation = Repo.preload(conversation, :participations)

	last_activity_id =
	fetch_latest_direct_activity_id_for_context(conversation.ap_id, %{
	user: user,
	blocking_user: user
	})

	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

	create_data =
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(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]

	listen_data =
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(listen_data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	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 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])
	\|> restrict_filtered(opts)
	\|> 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_direct_activity_id_for_context(String.t(), keyword() \| map()) ::
	FlakeId.Ecto.CompatType.t() \| nil
	def fetch_latest_direct_activity_id_for_context(context, opts \\ %{}) do
	context
	\|> fetch_activities_for_context_query(Map.merge(%{skip_preload: true}, opts))
	\|> restrict_visibility(%{visibility: "direct"})
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

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

	[Constants.as_public()]
	\|> fetch_activities_query(opts)
	\|> restrict_unlisted(opts)
	\|> Pagination.fetch_paginated(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
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	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)

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(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

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params)
	\|> Enum.reverse()
	end

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

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, :offset)
	\|> Enum.reverse()
	end

	defp user_activities_recipients(%{godmode: true}), do: []

	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_announce_object_actor(_query, %{announce_filtering_user: _, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_announce_object_actor(query, %{announce_filtering_user: %{ap_id: actor}}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'type' != ? or ?->>'actor' != ?",
	activity.data,
	"Announce",
	object.data,
	^actor
	)
	)
	end

	defp restrict_announce_object_actor(query, _), do: query

	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}) 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}) 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: true}) do
	from(
	[activity, object] in query,
	where: fragment("(?)->>'type' = ?", activity.data, "Create"),
	where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

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

	defp restrict_replies(query, %{
	reply_filtering_user: %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{} = user,
	reply_visibility: "following"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	- "?->>'inReplyTo' is null OR ? && array_remove(?, ?) OR ? = ?",
	+ """
	+ ?->>'type' != 'Create' -- This isn't a Create
	+ OR ?->>'inReplyTo' is null -- this isn't a reply
	+ OR ? && array_remove(?, ?) -- The recipient is us or one of our friends,
	+ -- unless they are the author (because authors
	+ -- are also part of the recipients). This leads
	+ -- to a bug that self-replies by friends won't
	+ -- show up.
	+ OR ? = ? -- The actor is us
	+ """,
	+ activity.data,
	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: true}) do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{with_muted: true}), 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 (? && ?)) or ? = ?)",
	activity.recipients,
	^blocked_ap_ids,
	activity.actor,
	^user.ap_id
	),
	where:
	fragment(
	"recipients_contain_blocked_domains(?, ?) = false",
	activity.recipients,
	^domain_blocks
	),
	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, %{restrict_unlisted: true}) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^[Constants.as_public()]
	)
	)
	end

	defp restrict_unlisted(query, _), do: query

	defp restrict_pinned(query, %{pinned: true, pinned_activity_ids: ids}) 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 restrict_filtered(query, %{user: %User{} = user}) do
	case Filter.compose_regex(user) do
	nil ->
	query

	regex ->
	from([activity, object] in query,
	where:
	fragment("not(?->>'content' ~* ?)", object.data, ^regex) or
	activity.actor == ^user.ap_id
	)
	end
	end

	defp restrict_filtered(query, %{blocking_user: %User{} = user}) do
	restrict_filtered(query, %{user: user})
	end

	defp restrict_filtered(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_chat_messages(query, %{include_chat_messages: true}), do: query

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

	defp exclude_invisible_actors(query, %{invisible_actors: true}), do: query

	defp exclude_invisible_actors(query, _opts) do
	invisible_ap_ids =
	User.Query.build(%{invisible: true, select: [:ap_id]})
	\|> Repo.all()
	\|> Enum.map(fn %{ap_id: ap_id} -> ap_id end)

	from([activity] in query, where: activity.actor not in ^invisible_ap_ids)
	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 =
	if opts[:blocking_user] && opts[:blocking_user] == source_user do
	[:block \| ap_id_relationships]
	else
	ap_id_relationships
	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_filtered(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)
	\|> restrict_announce_object_actor(opts)
	\|> restrict_filtered(opts)
	\|> Activity.restrict_deactivated_users()
	\|> exclude_poll_votes(opts)
	\|> exclude_chat_messages(opts)
	\|> exclude_invisible_actors(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, pagination_id: like.id})
	\|> order_by([like, _, _], desc_nulls_last: like.id)
	\|> Pagination.fetch_paginated(
	Map.merge(params, %{skip_order: true}),
	pagination
	)
	end

	defp maybe_update_cc(activities, [_ \| _] = list_memberships, %User{ap_id: user_ap_id}) do
	Enum.map(activities, fn
	%{data: %{"bcc" => [_ \| _] = bcc}} = activity ->
	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

	defp 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 = Maps.put_if_present(data, "actor", opts[:actor])

	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)
	\|> Map.new(fn %{"icon" => %{"url" => url}, "name" => name} ->
	{String.trim(name, ":"), url}
	end)

	locked = data["manuallyApprovesFollowers"] \|\| false
	capabilities = data["capabilities"] \|\| %{}
	accepts_chat_messages = capabilities["acceptsChatMessages"]
	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,
	accepts_chat_messages: accepts_chat_messages
	}

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

	def fetch_follow_information_for_user(user) do
	with {:ok, following_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.following_address,
	force_http: true
	),
	{:ok, hide_follows} <- collection_private(following_data),
	{:ok, followers_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address, force_http: true),
	{: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) do
	{:ok, object_to_user_data(data)}
	else
	e -> {:error, e}
	end
	end

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

	{:error, {:reject, reason} = e} ->
	Logger.info("Rejected user #{ap_id}: #{inspect(reason)}")
	{:error, e}

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

	def maybe_handle_clashing_nickname(data) do
	with nickname when is_binary(nickname) <- data[:nickname],
	%User{} = old_user <- User.get_by_nickname(nickname),
	{_, false} <- {:ap_id_comparison, data[:ap_id] == old_user.ap_id} do
	Logger.info(
	"Found an old user for #{nickname}, the old ap id is #{old_user.ap_id}, new one is #{
	data[:ap_id]
	}, renaming."
	)

	old_user
	\|> User.remote_user_changeset(%{nickname: "#{old_user.id}.#{old_user.nickname}"})
	\|> User.update_and_set_cache()
	else
	{:ap_id_comparison, true} ->
	Logger.info(
	"Found an old user for #{data[:nickname]}, but the ap id #{data[:ap_id]} is the same as the new user. Race condition? Not changing anything."
	)

	_ ->
	nil
	end
	end

	def make_user_from_ap_id(ap_id, opts \\ []) 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, opts) do
	if user do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	else
	maybe_handle_clashing_nickname(data)

	data
	\|> User.remote_user_changeset()
	\|> Repo.insert()
	\|> User.set_cache()
	end
	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
	defp 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/relay.ex b/lib/pleroma/web/activity_pub/relay.ex
	index b65710a94..6606e1780 100644
	--- a/lib/pleroma/web/activity_pub/relay.ex
	+++ b/lib/pleroma/web/activity_pub/relay.ex
	@@ -1,96 +1,108 @@
	# 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.Relay do
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	require Logger

	@nickname "relay"

	@spec ap_id() :: String.t()
	def ap_id, do: "#{Pleroma.Web.Endpoint.url()}/#{@nickname}"

	@spec get_actor() :: User.t() \| nil
	def get_actor, do: User.get_or_create_service_actor_by_ap_id(ap_id(), @nickname)

	@spec follow(String.t()) :: {:ok, Activity.t()} \| {:error, any()}
	def follow(target_instance) do
	with %User{} = local_user <- get_actor(),
	{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_instance),
	{:ok, _, _, activity} <- CommonAPI.follow(local_user, target_user) do
	Logger.info("relay: followed instance: #{target_instance}; id=#{activity.data["id"]}")
	{:ok, activity}
	else
	error -> format_error(error)
	end
	end

	- @spec unfollow(String.t()) :: {:ok, Activity.t()} \| {:error, any()}
	- def unfollow(target_instance) do
	+ @spec unfollow(String.t(), map()) :: {:ok, Activity.t()} \| {:error, any()}
	+ def unfollow(target_instance, opts \\ %{}) do
	with %User{} = local_user <- get_actor(),
	- {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_instance),
	+ {:ok, target_user} <- fetch_target_user(target_instance, opts),
	{:ok, activity} <- ActivityPub.unfollow(local_user, target_user) do
	- User.unfollow(local_user, target_user)
	+ case target_user.id do
	+ nil -> User.update_following_count(local_user)
	+ _ -> User.unfollow(local_user, target_user)
	+ end
	+
	Logger.info("relay: unfollowed instance: #{target_instance}: id=#{activity.data["id"]}")
	{:ok, activity}
	else
	error -> format_error(error)
	end
	end

	+ defp fetch_target_user(ap_id, opts) do
	+ case {opts[:force], User.get_or_fetch_by_ap_id(ap_id)} do
	+ {_, {:ok, %User{} = user}} -> {:ok, user}
	+ {true, _} -> {:ok, %User{ap_id: ap_id}}
	+ {_, error} -> error
	+ end
	+ end
	+
	@spec publish(any()) :: {:ok, Activity.t()} \| {:error, any()}
	def publish(%Activity{data: %{"type" => "Create"}} = activity) do
	with %User{} = user <- get_actor(),
	true <- Visibility.is_public?(activity) do
	CommonAPI.repeat(activity.id, user)
	else
	error -> format_error(error)
	end
	end

	def publish(_), do: {:error, "Not implemented"}

	@spec list() :: {:ok, [%{actor: String.t(), followed_back: boolean()}]} \| {:error, any()}
	def list do
	with %User{} = user <- get_actor() do
	accepted =
	user
	\|> following()
	\|> Enum.map(fn actor -> %{actor: actor, followed_back: true} end)

	without_accept =
	user
	\|> Pleroma.Activity.following_requests_for_actor()
	\|> Enum.map(fn activity -> %{actor: activity.data["object"], followed_back: false} end)
	\|> Enum.uniq()

	{:ok, accepted ++ without_accept}
	else
	error -> format_error(error)
	end
	end

	@spec following() :: [String.t()]
	def following do
	get_actor()
	\|> following()
	end

	defp following(user) do
	user
	\|> User.following_ap_ids()
	\|> Enum.uniq()
	end

	defp format_error({:error, error}), do: format_error(error)

	defp format_error(error) do
	Logger.error("error: #{inspect(error)}")
	{:error, error}
	end
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/relay_controller.ex b/lib/pleroma/web/admin_api/controllers/relay_controller.ex
	index 95d06dde7..6c19f09f7 100644
	--- a/lib/pleroma/web/admin_api/controllers/relay_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/relay_controller.ex
	@@ -1,67 +1,59 @@
	# 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.RelayController do
	use Pleroma.Web, :controller

	alias Pleroma.ModerationLog
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Web.ActivityPub.Relay

	require Logger

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:follows"], admin: true}
	when action in [:follow, :unfollow]
	)

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

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.Admin.RelayOperation

	def index(conn, _params) do
	with {:ok, list} <- Relay.list() do
	json(conn, %{relays: list})
	end
	end

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

	json(conn, %{actor: target, followed_back: target in Relay.following()})
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	- def unfollow(%{assigns: %{user: admin}, body_params: %{relay_url: target}} = conn, _) do
	- with {:ok, _message} <- Relay.unfollow(target) do
	- ModerationLog.insert_log(%{
	- action: "relay_unfollow",
	- actor: admin,
	- target: target
	- })
	+ def unfollow(%{assigns: %{user: admin}, body_params: %{relay_url: target} = params} = conn, _) do
	+ with {:ok, _message} <- Relay.unfollow(target, %{force: params[:force]}) do
	+ ModerationLog.insert_log(%{action: "relay_unfollow", actor: admin, target: target})

	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end
	end
	diff --git a/lib/pleroma/web/api_spec/cast_and_validate.ex b/lib/pleroma/web/api_spec/cast_and_validate.ex
	index fbfc27d6f..6d1a7ebbc 100644
	--- a/lib/pleroma/web/api_spec/cast_and_validate.ex
	+++ b/lib/pleroma/web/api_spec/cast_and_validate.ex
	@@ -1,139 +1,143 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2019-2020 Moxley Stratton, Mike Buhot <https://github.com/open-api-spex/open_api_spex>, MPL-2.0
	# Copyright © 2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.CastAndValidate do
	@moduledoc """
	This plug is based on [`OpenApiSpex.Plug.CastAndValidate`]
	(https://github.com/open-api-spex/open_api_spex/blob/master/lib/open_api_spex/plug/cast_and_validate.ex).
	The main difference is ignoring unexpected query params instead of throwing
	an error and a config option (`[Pleroma.Web.ApiSpec.CastAndValidate, :strict]`)
	to disable this behavior. Also, the default rendering error module
	is `Pleroma.Web.ApiSpec.RenderError`.
	"""

	@behaviour Plug

	alias Plug.Conn

	@impl Plug
	def init(opts) do
	opts
	\|> Map.new()
	\|> Map.put_new(:render_error, Pleroma.Web.ApiSpec.RenderError)
	end

	@impl Plug
	def call(%{private: %{open_api_spex: private_data}} = conn, %{
	operation_id: operation_id,
	render_error: render_error
	}) do
	spec = private_data.spec
	operation = private_data.operation_lookup[operation_id]

	content_type =
	case Conn.get_req_header(conn, "content-type") do
	[header_value \| _] ->
	header_value
	\|> String.split(";")
	\|> List.first()

	_ ->
	"application/json"
	end

	private_data = Map.put(private_data, :operation_id, operation_id)
	conn = Conn.put_private(conn, :open_api_spex, private_data)

	case cast_and_validate(spec, operation, conn, content_type, strict?()) do
	{:ok, conn} ->
	conn

	{:error, reason} ->
	opts = render_error.init(reason)

	conn
	\|> render_error.call(opts)
	\|> Plug.Conn.halt()
	end
	end

	def call(
	%{
	private: %{
	phoenix_controller: controller,
	phoenix_action: action,
	open_api_spex: private_data
	}
	} = conn,
	opts
	) do
	operation =
	case private_data.operation_lookup[{controller, action}] do
	nil ->
	operation_id = controller.open_api_operation(action).operationId
	operation = private_data.operation_lookup[operation_id]

	operation_lookup =
	private_data.operation_lookup
	\|> Map.put({controller, action}, operation)

	OpenApiSpex.Plug.Cache.adapter().put(
	private_data.spec_module,
	{private_data.spec, operation_lookup}
	)

	operation

	operation ->
	operation
	end

	if operation.operationId do
	call(conn, Map.put(opts, :operation_id, operation.operationId))
	else
	raise "operationId was not found in action API spec"
	end
	end

	def call(conn, opts), do: OpenApiSpex.Plug.CastAndValidate.call(conn, opts)

	defp cast_and_validate(spec, operation, conn, content_type, true = _strict) do
	OpenApiSpex.cast_and_validate(spec, operation, conn, content_type)
	end

	defp cast_and_validate(spec, operation, conn, content_type, false = _strict) do
	case OpenApiSpex.cast_and_validate(spec, operation, conn, content_type) do
	{:ok, conn} ->
	{:ok, conn}

	# Remove unexpected query params and cast/validate again
	{:error, errors} ->
	query_params =
	Enum.reduce(errors, conn.query_params, fn
	%{reason: :unexpected_field, name: name, path: [name]}, params ->
	Map.delete(params, name)

	+ # Filter out empty params
	+ %{reason: :invalid_type, path: [name_atom], value: ""}, params ->
	+ Map.delete(params, to_string(name_atom))
	+
	%{reason: :invalid_enum, name: nil, path: path, value: value}, params ->
	path = path \|> Enum.reverse() \|> tl() \|> Enum.reverse() \|> list_items_to_string()
	update_in(params, path, &List.delete(&1, value))

	_, params ->
	params
	end)

	conn = %Conn{conn \| query_params: query_params}
	OpenApiSpex.cast_and_validate(spec, operation, conn, content_type)
	end
	end

	defp list_items_to_string(list) do
	Enum.map(list, fn
	i when is_atom(i) -> to_string(i)
	i -> i
	end)
	end

	defp strict?, do: Pleroma.Config.get([__MODULE__, :strict], false)
	end
	diff --git a/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex b/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	index e06b2d164..f754bb9f5 100644
	--- a/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/admin/relay_operation.ex
	@@ -1,94 +1,104 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	import Pleroma.Web.ApiSpec.Helpers

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

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

	def follow_operation do
	%Operation{
	tags: ["Admin", "Relays"],
	summary: "Follow a Relay",
	operationId: "AdminAPI.RelayController.follow",
	security: [%{"oAuth" => ["write:follows"]}],
	parameters: admin_api_params(),
	requestBody: request_body("Parameters", relay_url()),
	responses: %{
	200 => Operation.response("Status", "application/json", relay())
	}
	}
	end

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

	defp relay do
	%Schema{
	type: :object,
	properties: %{
	actor: %Schema{
	type: :string,
	example: "https://example.com/relay"
	},
	followed_back: %Schema{
	type: :boolean,
	description: "Is relay followed back by this actor?"
	}
	}
	}
	end

	defp relay_url do
	%Schema{
	type: :object,
	properties: %{
	relay_url: %Schema{type: :string, format: :uri}
	}
	}
	end
	+
	+ defp relay_unfollow do
	+ %Schema{
	+ type: :object,
	+ properties: %{
	+ relay_url: %Schema{type: :string, format: :uri},
	+ force: %Schema{type: :boolean, default: false}
	+ }
	+ }
	+ end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex
	index efbfce75f..a56641426 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_emoji_file_operation.ex
	@@ -1,139 +1,139 @@
	# 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.PleromaEmojiFileOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

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

	def create_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Add new file to the pack",
	operationId: "PleromaAPI.EmojiPackController.add_file",
	security: [%{"oAuth" => ["write"]}],
	requestBody: request_body("Parameters", create_request(), required: true),
	parameters: [name_param()],
	responses: %{
	200 => Operation.response("Files Object", "application/json", files_object()),
	422 => Operation.response("Unprocessable Entity", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	409 => Operation.response("Conflict", "application/json", ApiError)
	}
	}
	end

	defp create_request do
	%Schema{
	type: :object,
	required: [:file],
	properties: %{
	file: %Schema{
	description:
	"File needs to be uploaded with the multipart request or link to remote file",
	anyOf: [
	%Schema{type: :string, format: :binary},
	%Schema{type: :string, format: :uri}
	]
	},
	shortcode: %Schema{
	type: :string,
	description:
	"Shortcode for new emoji, must be unique for all emoji. If not sended, shortcode will be taken from original filename."
	},
	filename: %Schema{
	type: :string,
	description:
	"New emoji file name. If not specified will be taken from original filename."
	}
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Add new file to the pack",
	operationId: "PleromaAPI.EmojiPackController.update_file",
	security: [%{"oAuth" => ["write"]}],
	requestBody: request_body("Parameters", update_request(), required: true),
	parameters: [name_param()],
	responses: %{
	200 => Operation.response("Files Object", "application/json", files_object()),
	404 => Operation.response("Not Found", "application/json", ApiError),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	409 => Operation.response("Conflict", "application/json", ApiError),
	422 => Operation.response("Unprocessable Entity", "application/json", ApiError)
	}
	}
	end

	defp update_request do
	%Schema{
	type: :object,
	required: [:shortcode, :new_shortcode, :new_filename],
	properties: %{
	shortcode: %Schema{
	type: :string,
	description: "Emoji file shortcode"
	},
	new_shortcode: %Schema{
	type: :string,
	description: "New emoji file shortcode"
	},
	new_filename: %Schema{
	type: :string,
	description: "New filename for emoji file"
	},
	force: %Schema{
	type: :boolean,
	description: "With true value to overwrite existing emoji with new shortcode",
	default: false
	}
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Delete emoji file from pack",
	operationId: "PleromaAPI.EmojiPackController.delete_file",
	security: [%{"oAuth" => ["write"]}],
	parameters: [
	name_param(),
	Operation.parameter(:shortcode, :query, :string, "File shortcode",
	example: "cofe",
	required: true
	)
	],
	responses: %{
	200 => Operation.response("Files Object", "application/json", files_object()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError),
	422 => Operation.response("Unprocessable Entity", "application/json", ApiError)
	}
	}
	end

	defp name_param do
	- Operation.parameter(:name, :path, :string, "Pack Name", example: "cofe", required: true)
	+ Operation.parameter(:name, :query, :string, "Pack Name", example: "cofe", required: true)
	end

	defp files_object do
	%Schema{
	type: :object,
	additionalProperties: %Schema{type: :string},
	description: "Object with emoji names as keys and filenames as values"
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	index 59548af13..79f52dcb3 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_emoji_pack_operation.ex
	@@ -1,313 +1,327 @@
	# 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.PleromaEmojiPackOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.ApiError

	import Pleroma.Web.ApiSpec.Helpers

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

	def remote_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Make request to another instance for emoji packs list",
	security: [%{"oAuth" => ["write"]}],
	- parameters: [url_param()],
	+ parameters: [
	+ url_param(),
	+ Operation.parameter(
	+ :page,
	+ :query,
	+ %Schema{type: :integer, default: 1},
	+ "Page"
	+ ),
	+ Operation.parameter(
	+ :page_size,
	+ :query,
	+ %Schema{type: :integer, default: 30},
	+ "Number of emoji to return"
	+ )
	+ ],
	operationId: "PleromaAPI.EmojiPackController.remote",
	responses: %{
	200 => emoji_packs_response(),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def index_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Lists local custom emoji packs",
	operationId: "PleromaAPI.EmojiPackController.index",
	parameters: [
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 50},
	"Number of emoji packs to return"
	)
	],
	responses: %{
	200 => emoji_packs_response()
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Show emoji pack",
	operationId: "PleromaAPI.EmojiPackController.show",
	parameters: [
	name_param(),
	Operation.parameter(
	:page,
	:query,
	%Schema{type: :integer, default: 1},
	"Page"
	),
	Operation.parameter(
	:page_size,
	:query,
	%Schema{type: :integer, default: 30},
	"Number of emoji to return"
	)
	],
	responses: %{
	200 => Operation.response("Emoji Pack", "application/json", emoji_pack()),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def archive_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Requests a local pack archive from the instance",
	operationId: "PleromaAPI.EmojiPackController.archive",
	parameters: [name_param()],
	responses: %{
	200 =>
	Operation.response("Archive file", "application/octet-stream", %Schema{
	type: :string,
	format: :binary
	}),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def download_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Download pack from another instance",
	operationId: "PleromaAPI.EmojiPackController.download",
	security: [%{"oAuth" => ["write"]}],
	requestBody: request_body("Parameters", download_request(), required: true),
	responses: %{
	200 => ok_response(),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	defp download_request do
	%Schema{
	type: :object,
	required: [:url, :name],
	properties: %{
	url: %Schema{
	type: :string,
	format: :uri,
	description: "URL of the instance to download from"
	},
	name: %Schema{type: :string, format: :uri, description: "Pack Name"},
	as: %Schema{type: :string, format: :uri, description: "Save as"}
	}
	}
	end

	def create_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Create an empty pack",
	operationId: "PleromaAPI.EmojiPackController.create",
	security: [%{"oAuth" => ["write"]}],
	parameters: [name_param()],
	responses: %{
	200 => ok_response(),
	400 => Operation.response("Not Found", "application/json", ApiError),
	409 => Operation.response("Conflict", "application/json", ApiError),
	500 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def delete_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Delete a custom emoji pack",
	operationId: "PleromaAPI.EmojiPackController.delete",
	security: [%{"oAuth" => ["write"]}],
	parameters: [name_param()],
	responses: %{
	200 => ok_response(),
	400 => Operation.response("Bad Request", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Updates (replaces) pack metadata",
	operationId: "PleromaAPI.EmojiPackController.update",
	security: [%{"oAuth" => ["write"]}],
	requestBody: request_body("Parameters", update_request(), required: true),
	parameters: [name_param()],
	responses: %{
	200 => Operation.response("Metadata", "application/json", metadata()),
	400 => Operation.response("Bad Request", "application/json", ApiError)
	}
	}
	end

	def import_from_filesystem_operation do
	%Operation{
	tags: ["Emoji Packs"],
	summary: "Imports packs from filesystem",
	operationId: "PleromaAPI.EmojiPackController.import",
	security: [%{"oAuth" => ["write"]}],
	responses: %{
	200 =>
	Operation.response("Array of imported pack names", "application/json", %Schema{
	type: :array,
	items: %Schema{type: :string}
	})
	}
	}
	end

	defp name_param do
	- Operation.parameter(:name, :path, :string, "Pack Name", example: "cofe", required: true)
	+ Operation.parameter(:name, :query, :string, "Pack Name", example: "cofe", required: true)
	end

	defp url_param do
	Operation.parameter(
	:url,
	:query,
	%Schema{type: :string, format: :uri},
	"URL of the instance",
	required: true
	)
	end

	defp ok_response do
	Operation.response("Ok", "application/json", %Schema{type: :string, example: "ok"})
	end

	defp emoji_packs_response do
	Operation.response(
	"Object with pack names as keys and pack contents as values",
	"application/json",
	%Schema{
	type: :object,
	additionalProperties: emoji_pack(),
	example: %{
	"emojos" => emoji_pack().example
	}
	}
	)
	end

	defp emoji_pack do
	%Schema{
	title: "EmojiPack",
	type: :object,
	properties: %{
	files: files_object(),
	pack: %Schema{
	type: :object,
	properties: %{
	license: %Schema{type: :string},
	homepage: %Schema{type: :string, format: :uri},
	description: %Schema{type: :string},
	"can-download": %Schema{type: :boolean},
	"share-files": %Schema{type: :boolean},
	"download-sha256": %Schema{type: :string}
	}
	}
	},
	example: %{
	"files" => %{"emacs" => "emacs.png", "guix" => "guix.png"},
	"pack" => %{
	"license" => "Test license",
	"homepage" => "https://pleroma.social",
	"description" => "Test description",
	"can-download" => true,
	"share-files" => true,
	"download-sha256" => "57482F30674FD3DE821FF48C81C00DA4D4AF1F300209253684ABA7075E5FC238"
	}
	}
	}
	end

	defp files_object do
	%Schema{
	type: :object,
	additionalProperties: %Schema{type: :string},
	description: "Object with emoji names as keys and filenames as values"
	}
	end

	defp update_request do
	%Schema{
	type: :object,
	properties: %{
	metadata: %Schema{
	type: :object,
	description: "Metadata to replace the old one",
	properties: %{
	license: %Schema{type: :string},
	homepage: %Schema{type: :string, format: :uri},
	description: %Schema{type: :string},
	"fallback-src": %Schema{
	type: :string,
	format: :uri,
	description: "Fallback url to download pack from"
	},
	"fallback-src-sha256": %Schema{
	type: :string,
	description: "SHA256 encoded for fallback pack archive"
	},
	"share-files": %Schema{type: :boolean, description: "Is pack allowed for sharing?"}
	}
	}
	}
	}
	end

	defp metadata do
	%Schema{
	type: :object,
	properties: %{
	license: %Schema{type: :string},
	homepage: %Schema{type: :string, format: :uri},
	description: %Schema{type: :string},
	"fallback-src": %Schema{
	type: :string,
	format: :uri,
	description: "Fallback url to download pack from"
	},
	"fallback-src-sha256": %Schema{
	type: :string,
	description: "SHA256 encoded for fallback pack archive"
	},
	"share-files": %Schema{type: :boolean, description: "Is pack allowed for sharing?"}
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex b/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	index e3969fee1..6696f8b92 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/emoji_pack_controller.ex
	@@ -1,199 +1,200 @@
	defmodule Pleroma.Web.PleromaAPI.EmojiPackController do
	use Pleroma.Web, :controller

	alias Pleroma.Emoji.Pack

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(
	Pleroma.Plugs.OAuthScopesPlug,
	%{scopes: ["write"], admin: true}
	when action in [
	:import_from_filesystem,
	:remote,
	:download,
	:create,
	:update,
	:delete
	]
	)

	@skip_plugs [Pleroma.Plugs.OAuthScopesPlug, Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug]
	plug(:skip_plug, @skip_plugs when action in [:index, :show, :archive])

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.PleromaEmojiPackOperation

	- def remote(conn, %{url: url}) do
	- with {:ok, packs} <- Pack.list_remote(url) do
	+ def remote(conn, params) do
	+ with {:ok, packs} <-
	+ Pack.list_remote(url: params.url, page_size: params.page_size, page: params.page) do
	json(conn, packs)
	else
	{:error, :not_shareable} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "The requested instance does not support sharing emoji packs"})
	end
	end

	def index(conn, params) do
	emoji_path =
	[:instance, :static_dir]
	\|> Pleroma.Config.get!()
	\|> Path.join("emoji")

	with {:ok, packs, count} <- Pack.list_local(page: params.page, page_size: params.page_size) do
	json(conn, %{packs: packs, count: count})
	else
	{:error, :create_dir, e} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Failed to create the emoji pack directory at #{emoji_path}: #{e}"})

	{:error, :ls, e} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{
	error: "Failed to get the contents of the emoji pack directory at #{emoji_path}: #{e}"
	})
	end
	end

	def show(conn, %{name: name, page: page, page_size: page_size}) do
	name = String.trim(name)

	with {:ok, pack} <- Pack.show(name: name, page: page, page_size: page_size) do
	json(conn, pack)
	else
	{:error, :not_found} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})
	end
	end

	def archive(conn, %{name: name}) do
	with {:ok, archive} <- Pack.get_archive(name) do
	send_download(conn, {:binary, archive}, filename: "#{name}.zip")
	else
	{:error, :cant_download} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{
	error:
	"Pack #{name} cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
	})

	{:error, :not_found} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})
	end
	end

	def download(%{body_params: %{url: url, name: name} = params} = conn, _) do
	with {:ok, _pack} <- Pack.download(name, url, params[:as]) do
	json(conn, "ok")
	else
	{:error, :not_shareable} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "The requested instance does not support sharing emoji packs"})

	{:error, :invalid_checksum} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "SHA256 for the pack doesn't match the one sent by the server"})

	{:error, e} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: e})
	end
	end

	def create(conn, %{name: name}) do
	name = String.trim(name)

	with {:ok, _pack} <- Pack.create(name) do
	json(conn, "ok")
	else
	{:error, :eexist} ->
	conn
	\|> put_status(:conflict)
	\|> json(%{error: "A pack named \"#{name}\" already exists"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})

	{:error, _} ->
	render_error(
	conn,
	:internal_server_error,
	"Unexpected error occurred while creating pack."
	)
	end
	end

	def delete(conn, %{name: name}) do
	name = String.trim(name)

	with {:ok, deleted} when deleted != [] <- Pack.delete(name) do
	json(conn, "ok")
	else
	{:ok, []} ->
	conn
	\|> put_status(:not_found)
	\|> json(%{error: "Pack #{name} does not exist"})

	{:error, :empty_values} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "pack name cannot be empty"})

	{:error, _, _} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Couldn't delete the pack #{name}"})
	end
	end

	def update(%{body_params: %{metadata: metadata}} = conn, %{name: name}) do
	with {:ok, pack} <- Pack.update_metadata(name, metadata) do
	json(conn, pack.pack)
	else
	{:error, :incomplete} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: "The fallback archive does not have all files specified in pack.json"})

	{:error, _} ->
	render_error(
	conn,
	:internal_server_error,
	"Unexpected error occurred while updating pack metadata."
	)
	end
	end

	def import_from_filesystem(conn, _params) do
	with {:ok, names} <- Pack.import_from_filesystem() do
	json(conn, names)
	else
	{:error, :no_read_write} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Error: emoji pack directory must be writable"})

	{:error, _} ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: "Error accessing emoji pack directory"})
	end
	end
	end
	diff --git a/lib/pleroma/web/push/impl.ex b/lib/pleroma/web/push/impl.ex
	index 16368485e..da535aa68 100644
	--- a/lib/pleroma/web/push/impl.ex
	+++ b/lib/pleroma/web/push/impl.ex
	@@ -1,185 +1,185 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.Impl do
	@moduledoc "The module represents implementation push web notification"

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.Metadata.Utils
	alias Pleroma.Web.Push.Subscription

	require Logger
	import Ecto.Query

	@types ["Create", "Follow", "Announce", "Like", "Move"]

	@doc "Performs sending notifications for user subscriptions"
	- @spec perform(Notification.t()) :: list(any) \| :error
	+ @spec perform(Notification.t()) :: list(any) \| :error \| {:error, :unknown_type}
	def perform(
	%{
	activity: %{data: %{"type" => activity_type}} = activity,
	user: %User{id: user_id}
	} = notification
	)
	when activity_type in @types do
	actor = User.get_cached_by_ap_id(notification.activity.data["actor"])

	mastodon_type = notification.type
	gcm_api_key = Application.get_env(:web_push_encryption, :gcm_api_key)
	avatar_url = User.avatar_url(actor)
	object = Object.normalize(activity, false)
	user = User.get_cached_by_id(user_id)
	direct_conversation_id = Activity.direct_conversation_id(activity, user)

	for subscription <- fetch_subscriptions(user_id),
	Subscription.enabled?(subscription, mastodon_type) do
	%{
	access_token: subscription.token.token,
	notification_id: notification.id,
	notification_type: mastodon_type,
	icon: avatar_url,
	preferred_locale: "en",
	pleroma: %{
	activity_id: notification.activity.id,
	direct_conversation_id: direct_conversation_id
	}
	}
	\|> Map.merge(build_content(notification, actor, object, mastodon_type))
	\|> Jason.encode!()
	\|> push_message(build_sub(subscription), gcm_api_key, subscription)
	end
	\|> (&{:ok, &1}).()
	end

	def perform(_) do
	Logger.warn("Unknown notification type")
	{:error, :unknown_type}
	end

	@doc "Push message to web"
	def push_message(body, sub, api_key, subscription) do
	case WebPushEncryption.send_web_push(body, sub, api_key) do
	- {:ok, %{status_code: code}} when 400 <= code and code < 500 ->
	+ {:ok, %{status: code}} when code in 400..499 ->
	Logger.debug("Removing subscription record")
	Repo.delete!(subscription)
	:ok

	- {:ok, %{status_code: code}} when 200 <= code and code < 300 ->
	+ {:ok, %{status: code}} when code in 200..299 ->
	:ok

	- {:ok, %{status_code: code}} ->
	+ {:ok, %{status: code}} ->
	Logger.error("Web Push Notification failed with code: #{code}")
	:error

	- _ ->
	- Logger.error("Web Push Notification failed with unknown error")
	+ error ->
	+ Logger.error("Web Push Notification failed with #{inspect(error)}")
	:error
	end
	end

	@doc "Gets user subscriptions"
	def fetch_subscriptions(user_id) do
	Subscription
	\|> where(user_id: ^user_id)
	\|> preload(:token)
	\|> Repo.all()
	end

	def build_sub(subscription) do
	%{
	keys: %{
	p256dh: subscription.key_p256dh,
	auth: subscription.key_auth
	},
	endpoint: subscription.endpoint
	}
	end

	def build_content(notification, actor, object, mastodon_type \\ nil)

	def build_content(
	%{
	user: %{notification_settings: %{hide_notification_contents: true}}
	} = notification,
	_actor,
	_object,
	mastodon_type
	) do
	%{body: format_title(notification, mastodon_type)}
	end

	def build_content(notification, actor, object, mastodon_type) do
	mastodon_type = mastodon_type \|\| notification.type

	%{
	title: format_title(notification, mastodon_type),
	body: format_body(notification, actor, object, mastodon_type)
	}
	end

	def format_body(activity, actor, object, mastodon_type \\ nil)

	def format_body(_activity, actor, %{data: %{"type" => "ChatMessage", "content" => content}}, _) do
	case content do
	nil -> "@#{actor.nickname}: (Attachment)"
	content -> "@#{actor.nickname}: #{Utils.scrub_html_and_truncate(content, 80)}"
	end
	end

	def format_body(
	%{activity: %{data: %{"type" => "Create"}}},
	actor,
	%{data: %{"content" => content}},
	_mastodon_type
	) do
	"@#{actor.nickname}: #{Utils.scrub_html_and_truncate(content, 80)}"
	end

	def format_body(
	%{activity: %{data: %{"type" => "Announce"}}},
	actor,
	%{data: %{"content" => content}},
	_mastodon_type
	) do
	"@#{actor.nickname} repeated: #{Utils.scrub_html_and_truncate(content, 80)}"
	end

	def format_body(
	%{activity: %{data: %{"type" => type}}} = notification,
	actor,
	_object,
	mastodon_type
	)
	when type in ["Follow", "Like"] do
	mastodon_type = mastodon_type \|\| notification.type

	case mastodon_type do
	"follow" -> "@#{actor.nickname} has followed you"
	"follow_request" -> "@#{actor.nickname} has requested to follow you"
	"favourite" -> "@#{actor.nickname} has favorited your post"
	end
	end

	def format_title(activity, mastodon_type \\ nil)

	def format_title(%{activity: %{data: %{"directMessage" => true}}}, _mastodon_type) do
	"New Direct Message"
	end

	def format_title(%{type: type}, mastodon_type) do
	case mastodon_type \|\| type do
	"mention" -> "New Mention"
	"follow" -> "New Follower"
	"follow_request" -> "New Follow Request"
	"reblog" -> "New Repeat"
	"favourite" -> "New Favorite"
	"pleroma:chat_mention" -> "New Chat Message"
	type -> "New #{String.capitalize(type \|\| "event")}"
	end
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 42a9db21d..e22b31b4c 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,738 +1,748 @@
	# 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)
	patch("/users/approve", AdminAPIController, :user_approve)
	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", RelayController, :index)
	post("/relay", RelayController, :follow)
	delete("/relay", RelayController, :unfollow)

	post("/users/invite_token", InviteController, :create)
	get("/users/invites", InviteController, :index)
	post("/users/revoke_invite", InviteController, :revoke)
	post("/users/email_invite", InviteController, :email)

	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("/users/:nickname/chats", AdminAPIController, :list_user_chats)

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

	get("/instance_document/:name", InstanceDocumentController, :show)
	patch("/instance_document/:name", InstanceDocumentController, :update)
	delete("/instance_document/:name", InstanceDocumentController, :delete)

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

	get("/reports", ReportController, :index)
	get("/reports/:id", ReportController, :show)
	patch("/reports", ReportController, :update)
	post("/reports/:id/notes", ReportController, :notes_create)
	delete("/reports/:report_id/notes/:id", ReportController, :notes_delete)

	get("/statuses/:id", StatusController, :show)
	put("/statuses/:id", StatusController, :update)
	delete("/statuses/:id", StatusController, :delete)
	get("/statuses", StatusController, :index)

	get("/config", ConfigController, :show)
	post("/config", ConfigController, :update)
	get("/config/descriptions", ConfigController, :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", OAuthAppController, :index)
	post("/oauth_app", OAuthAppController, :create)
	patch("/oauth_app/:id", OAuthAppController, :update)
	delete("/oauth_app/:id", OAuthAppController, :delete)

	get("/media_proxy_caches", MediaProxyCacheController, :index)
	post("/media_proxy_caches/delete", MediaProxyCacheController, :delete)
	post("/media_proxy_caches/purge", MediaProxyCacheController, :purge)

	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)
	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	end

	scope "/api/pleroma/emoji", Pleroma.Web.PleromaAPI do
	+ scope "/pack" do
	+ pipe_through(:admin_api)
	+
	+ post("/", EmojiPackController, :create)
	+ patch("/", EmojiPackController, :update)
	+ delete("/", EmojiPackController, :delete)
	+ end
	+
	+ scope "/pack" do
	+ pipe_through(:api)
	+
	+ get("/", EmojiPackController, :show)
	+ end
	+
	# 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", EmojiFileController, :create)
	- patch("/:name/files", EmojiFileController, :update)
	- delete("/:name/files", EmojiFileController, :delete)
	+ post("/files", EmojiFileController, :create)
	+ patch("/files", EmojiFileController, :update)
	+ delete("/files", EmojiFileController, :delete)
	end

	# Pack info / downloading
	scope "/packs" do
	pipe_through(:api)
	+
	get("/", EmojiPackController, :index)
	- get("/:name", EmojiPackController, :show)
	- get("/:name/archive", EmojiPackController, :archive)
	+ get("/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)
	end

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

	post("/mutes_import", UserImportController, :mutes)
	post("/blocks_import", UserImportController, :blocks)
	post("/follow_import", UserImportController, :follow)

	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)

	post("/chats/by-account-id/:id", ChatController, :create)
	get("/chats", ChatController, :index)
	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)
	post("/chats/:id/messages", ChatController, :post_chat_message)
	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	post("/chats/:id/read", ChatController, :mark_as_read)
	post("/chats/:id/messages/:message_id/read", ChatController, :mark_message_as_read)

	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)

	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)

	# Backend-obscure settings blob for MastoFE, don't parse/reuse elsewhere
	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("/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

	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)

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	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)

	get("/embed/:id", EmbedController, :show)
	end

	scope "/proxy/", Pleroma.Web.MediaProxy do
	get("/preview/:sig/:url", MediaProxyController, :preview)
	get("/preview/:sig/:url/:filename", MediaProxyController, :preview)
	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_with_preload)

	options("/*path", RedirectController, :empty)
	end
	end
	diff --git a/mix.exs b/mix.exs
	index 18f748672..b9ce8c500 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,325 +1,325 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("2.1.50"),
	elixir: "~> 1.9",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: [:phoenix, :gettext] ++ Mix.compilers(),
	elixirc_options: [warnings_as_errors: warnings_as_errors(Mix.env())],
	xref: [exclude: [:eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: ExCoveralls],
	preferred_cli_env: ["coveralls.html": :test],
	# Docs
	name: "Pleroma",
	homepage_url: "https://pleroma.social/",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	docs: [
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	logo: "priv/static/static/logo.png",
	extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/*/.md"),
	groups_for_extras: [
	"Installation manuals": Path.wildcard("docs/installation/*.md"),
	Configuration: Path.wildcard("docs/config/*.md"),
	Administration: Path.wildcard("docs/admin/*.md"),
	"Pleroma's APIs and Mastodon API extensions": Path.wildcard("docs/api/*.md")
	],
	main: "readme",
	output: "priv/static/doc"
	],
	releases: [
	pleroma: [
	include_executables_for: [:unix],
	applications: [ex_syslogger: :load, syslog: :load, eldap: :transient],
	steps: [:assemble, &put_otp_version/1, &copy_files/1, &copy_nginx_config/1]
	]
	]
	]
	end

	def put_otp_version(%{path: target_path} = release) do
	File.write!(
	Path.join([target_path, "OTP_VERSION"]),
	Pleroma.OTPVersion.version()
	)

	release
	end

	def copy_files(%{path: target_path} = release) do
	File.cp_r!("./rel/files", target_path)
	release
	end

	def copy_nginx_config(%{path: target_path} = release) do
	File.cp!(
	"./installation/pleroma.nginx",
	Path.join([target_path, "installation", "pleroma.nginx"])
	)

	release
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[
	mod: {Pleroma.Application, []},
	extra_applications: [
	:logger,
	:runtime_tools,
	:comeonin,
	:quack,
	:fast_sanitize,
	:ssl
	],
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:benchmark), do: ["lib", "benchmarks"]
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	defp warnings_as_errors(:prod), do: false
	defp warnings_as_errors(_), do: true

	# Specifies OAuth dependencies.
	defp oauth_deps do
	oauth_strategy_packages =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(fn strategy_entry ->
	with [_strategy, dependency] <- String.split(strategy_entry, ":") do
	dependency
	else
	[strategy] -> "ueberauth_#{strategy}"
	end
	end)

	for s <- oauth_strategy_packages, do: {String.to_atom(s), ">= 0.0.0"}
	end

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix, "~> 1.4.17"},
	{:tzdata, "~> 1.0.3"},
	{:plug_cowboy, "~> 2.3"},
	{:phoenix_pubsub, "~> 1.1"},
	{:phoenix_ecto, "~> 4.0"},
	{:ecto_enum, "~> 1.4"},
	{:ecto_sql, "~> 3.4.4"},
	{:postgrex, ">= 0.15.5"},
	- {:oban, "~> 2.0.0"},
	+ {:oban, "~> 2.1.0"},
	{:gettext, "~> 0.18"},
	{:pbkdf2_elixir, "~> 1.2"},
	{:bcrypt_elixir, "~> 2.2"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:fast_sanitize, "~> 0.2.0"},
	{:html_entities, "~> 0.5", override: true},
	{:phoenix_html, "~> 2.14"},
	{:calendar, "~> 1.0"},
	{:cachex, "~> 3.2"},
	{:poison, "~> 3.0", override: true},
	{:tesla,
	git: "https://github.com/teamon/tesla/",
	ref: "9f7261ca49f9f901ceb73b60219ad6f8a9f6aa30",
	override: true},
	{:castore, "~> 0.1"},
	{:cowlib, "~> 2.9", override: true},
	{:gun,
	github: "ninenines/gun", ref: "921c47146b2d9567eac7e9a4d2ccc60fffd4f327", override: true},
	{:jason, "~> 1.2"},
	{:mogrify, "~> 0.7.4"},
	{:ex_aws, "~> 2.1"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.6.6"},
	{:earmark, "1.4.3"},
	{:bbcode_pleroma, "~> 0.2.0"},
	{:crypt,
	git: "https://github.com/msantos/crypt.git",
	ref: "f63a705f92c26955977ee62a313012e309a4d77a"},
	{:cors_plug, "~> 2.0"},
	{:web_push_encryption, "~> 0.3"},
	{:swoosh, "~> 1.0"},
	{:phoenix_swoosh, "~> 0.3"},
	{:gen_smtp, "~> 0.13"},
	{:ex_syslogger, "~> 1.4"},
	{:floki, "~> 0.27"},
	{:timex, "~> 3.6"},
	{:ueberauth, "~> 0.4"},
	{:linkify, "~> 0.2.0"},
	{:http_signatures, "~> 0.1.0"},
	{:telemetry, "~> 0.3"},
	{:poolboy, "~> 1.5"},
	{:prometheus, "~> 4.6"},
	{:prometheus_ex, "~> 3.0"},
	{:prometheus_plugs, "~> 1.1"},
	{:prometheus_phoenix, "~> 1.3"},
	{:prometheus_ecto, "~> 1.4"},
	{:recon, "~> 2.5"},
	{:quack, "~> 0.1.1"},
	{:joken, "~> 2.0"},
	{:benchee, "~> 1.0"},
	{:pot, "~> 0.11"},
	{:esshd, "~> 0.1.0", runtime: Application.get_env(:esshd, :enabled, false)},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:flake_id, "~> 0.1.0"},
	{:concurrent_limiter,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/concurrent_limiter.git",
	ref: "d81be41024569330f296fc472e24198d7499ba78"},
	{:remote_ip,
	git: "https://git.pleroma.social/pleroma/remote_ip.git",
	ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"},
	{:captcha,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git",
	ref: "e0f16822d578866e186a0974d65ad58cddc1e2ab"},
	{:restarter, path: "./restarter"},
	{:open_api_spex,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/open_api_spex.git",
	ref: "f296ac0924ba3cf79c7a588c4c252889df4c2edd"},

	## dev & test
	{:ex_doc, "~> 0.22", only: :dev, runtime: false},
	{:ex_machina, "~> 2.4", only: :test},
	{:credo, "~> 1.4", only: [:dev, :test], runtime: false},
	{:mock, "~> 0.3.5", only: :test},
	# temporary downgrade for excoveralls, hackney until hackney max_connections bug will be fixed
	{:excoveralls, "0.12.3", only: :test},
	{:hackney, "1.15.2", override: true},
	{:mox, "~> 0.5", only: :test},
	{:websocket_client, git: "https://github.com/jeremyong/websocket_client.git", only: :test}
	] ++ oauth_deps()
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.migrate": ["pleroma.ecto.migrate"],
	"ecto.rollback": ["pleroma.ecto.rollback"],
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	test: ["ecto.create --quiet", "ecto.migrate", "test"],
	docs: ["pleroma.docs", "docs"],
	analyze: ["credo --strict --only=warnings,todo,fixme,consistency,readability"]
	]
	end

	# Builds a version string made of:
	# * the application version
	# * a pre-release if ahead of the tag: the describe string (-count-commithash)
	# * branch name
	# * build metadata:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	identifier_filter = ~r/[^0-9a-z\-]+/i

	git_available? = match?({_output, 0}, System.cmd("sh", ["-c", "command -v git"]))

	git_pre_release =
	if git_available? do
	{tag, tag_err} =
	System.cmd("git", ["describe", "--tags", "--abbrev=0"], stderr_to_stdout: true)

	{describe, describe_err} = System.cmd("git", ["describe", "--tags", "--abbrev=8"])
	{commit_hash, commit_hash_err} = System.cmd("git", ["rev-parse", "--short", "HEAD"])

	# Pre-release version, denoted from patch version with a hyphen
	cond do
	tag_err == 0 and describe_err == 0 ->
	describe
	\|> String.trim()
	\|> String.replace(String.trim(tag), "")
	\|> String.trim_leading("-")
	\|> String.trim()

	commit_hash_err == 0 ->
	"0-g" <> String.trim(commit_hash)

	true ->
	nil
	end
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with true <- git_available?,
	{branch_name, 0} <- System.cmd("git", ["rev-parse", "--abbrev-ref", "HEAD"]),
	branch_name <- String.trim(branch_name),
	branch_name <- System.get_env("PLEROMA_BUILD_BRANCH") \|\| branch_name,
	true <-
	!Enum.any?(["master", "HEAD", "release/", "stable"], fn name ->
	String.starts_with?(name, branch_name)
	end) do
	branch_name =
	branch_name
	\|> String.trim()
	\|> String.replace(identifier_filter, "-")

	branch_name
	else
	_ -> ""
	end

	build_name =
	cond do
	name = Application.get_env(:pleroma, :build_name) -> name
	name = System.get_env("PLEROMA_BUILD_NAME") -> name
	true -> nil
	end

	env_name = if Mix.env() != :prod, do: to_string(Mix.env())
	env_override = System.get_env("PLEROMA_BUILD_ENV")

	env_name =
	case env_override do
	nil -> env_name
	env_override when env_override in ["", "prod"] -> nil
	env_override -> env_override
	end

	# Pre-release version, denoted by appending a hyphen
	# and a series of dot separated identifiers
	pre_release =
	[git_pre_release, branch_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "-" <> String.replace(string, identifier_filter, "-")
	end).()

	# Build metadata, denoted with a plus sign
	build_metadata =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "+" <> String.replace(string, identifier_filter, "-")
	end).()

	[version, pre_release, build_metadata]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end
	end
	diff --git a/mix.lock b/mix.lock
	index adb3f024a..2603f70c0 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,124 +1,124 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm", "11b18c220bcc2eab63b5470c038ef10eb6783bcb1fcdb11aa4137defa5ac1bb8"},
	"base62": {:hex, :base62, "1.2.1", "4866763e08555a7b3917064e9eef9194c41667276c51b59de2bc42c6ea65f806", [:mix], [{:custom_base, "~> 0.2.1", [hex: :custom_base, repo: "hexpm", optional: false]}], "hexpm", "3b29948de2013d3f93aa898c884a9dff847e7aec75d9d6d8c1dc4c61c2716c42"},
	"base64url": {:hex, :base64url, "0.0.1", "36a90125f5948e3afd7be97662a1504b934dd5dac78451ca6e9abf85a10286be", [:rebar], [], "hexpm"},
	"bbcode": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/bbcode.git", "f2d267675e9a7e1ad1ea9beb4cc23382762b66c2", [ref: "v0.2.0"]},
	"bbcode_pleroma": {:hex, :bbcode_pleroma, "0.2.0", "d36f5bca6e2f62261c45be30fa9b92725c0655ad45c99025cb1c3e28e25803ef", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "19851074419a5fedb4ef49e1f01b30df504bb5dbb6d6adfc135238063bebd1c3"},
	"bcrypt_elixir": {:hex, :bcrypt_elixir, "2.2.0", "3df902b81ce7fa8867a2ae30d20a1da6877a2c056bfb116fd0bc8a5f0190cea4", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "762be3fcb779f08207531bc6612cca480a338e4b4357abb49f5ce00240a77d1e"},
	"benchee": {:hex, :benchee, "1.0.1", "66b211f9bfd84bd97e6d1beaddf8fc2312aaabe192f776e8931cb0c16f53a521", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}], "hexpm", "3ad58ae787e9c7c94dd7ceda3b587ec2c64604563e049b2a0e8baafae832addb"},
	"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm", "7af5c7e09fe1d40f76c8e4f9dd2be7cebd83909f31fee7cd0e9eadc567da8353"},
	"cachex": {:hex, :cachex, "3.2.0", "a596476c781b0646e6cb5cd9751af2e2974c3e0d5498a8cab71807618b74fe2f", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:jumper, "~> 1.0", [hex: :jumper, repo: "hexpm", optional: false]}, {:sleeplocks, "~> 1.1", [hex: :sleeplocks, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm", "aef93694067a43697ae0531727e097754a9e992a1e7946296f5969d6dd9ac986"},
	"calendar": {:hex, :calendar, "1.0.0", "f52073a708528482ec33d0a171954ca610fe2bd28f1e871f247dc7f1565fa807", [:mix], [{:tzdata, "~> 0.5.20 or ~> 0.1.201603 or ~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "990e9581920c82912a5ee50e62ff5ef96da6b15949a2ee4734f935fdef0f0a6f"},
	"captcha": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git", "e0f16822d578866e186a0974d65ad58cddc1e2ab", [ref: "e0f16822d578866e186a0974d65ad58cddc1e2ab"]},
	"castore": {:hex, :castore, "0.1.7", "1ca19eee705cde48c9e809e37fdd0730510752cc397745e550f6065a56a701e9", [:mix], [], "hexpm", "a2ae2c13d40e9c308387f1aceb14786dca019ebc2a11484fb2a9f797ea0aa0d8"},
	"certifi": {:hex, :certifi, "2.5.1", "867ce347f7c7d78563450a18a6a28a8090331e77fa02380b4a21962a65d36ee5", [:rebar3], [{:parse_trans, "~>3.3", [hex: :parse_trans, repo: "hexpm", optional: false]}], "hexpm", "805abd97539caf89ec6d4732c91e62ba9da0cda51ac462380bbd28ee697a8c42"},
	"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
	"comeonin": {:hex, :comeonin, "5.3.1", "7fe612b739c78c9c1a75186ef2d322ce4d25032d119823269d0aa1e2f1e20025", [:mix], [], "hexpm", "d6222483060c17f0977fad1b7401ef0c5863c985a64352755f366aee3799c245"},
	"concurrent_limiter": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/concurrent_limiter.git", "d81be41024569330f296fc472e24198d7499ba78", [ref: "d81be41024569330f296fc472e24198d7499ba78"]},
	"connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm", "4a0850c9be22a43af9920a71ab17c051f5f7d45c209e40269a1938832510e4d9"},
	"cors_plug": {:hex, :cors_plug, "2.0.2", "2b46083af45e4bc79632bd951550509395935d3e7973275b2b743bd63cc942ce", [:mix], [{:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "f0d0e13f71c51fd4ef8b2c7e051388e4dfb267522a83a22392c856de7e46465f"},
	"cowboy": {:hex, :cowboy, "2.8.0", "f3dc62e35797ecd9ac1b50db74611193c29815401e53bac9a5c0577bd7bc667d", [:rebar3], [{:cowlib, "~> 2.9.1", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.7.1", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "4643e4fba74ac96d4d152c75803de6fad0b3fa5df354c71afdd6cbeeb15fac8a"},
	"cowlib": {:hex, :cowlib, "2.9.1", "61a6c7c50cf07fdd24b2f45b89500bb93b6686579b069a89f88cb211e1125c78", [:rebar3], [], "hexpm", "e4175dc240a70d996156160891e1c62238ede1729e45740bdd38064dad476170"},
	"credo": {:hex, :credo, "1.4.0", "92339d4cbadd1e88b5ee43d427b639b68a11071b6f73854e33638e30a0ea11f5", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "1fd3b70dce216574ce3c18bdf510b57e7c4c85c2ec9cad4bff854abaf7e58658"},
	"crontab": {:hex, :crontab, "1.1.8", "2ce0e74777dfcadb28a1debbea707e58b879e6aa0ffbf9c9bb540887bce43617", [:mix], [{:ecto, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	"crypt": {:git, "https://github.com/msantos/crypt.git", "f63a705f92c26955977ee62a313012e309a4d77a", [ref: "f63a705f92c26955977ee62a313012e309a4d77a"]},
	"custom_base": {:hex, :custom_base, "0.2.1", "4a832a42ea0552299d81652aa0b1f775d462175293e99dfbe4d7dbaab785a706", [:mix], [], "hexpm", "8df019facc5ec9603e94f7270f1ac73ddf339f56ade76a721eaa57c1493ba463"},
	"db_connection": {:hex, :db_connection, "2.2.2", "3bbca41b199e1598245b716248964926303b5d4609ff065125ce98bcd368939e", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm", "642af240d8a8affb93b4ba5a6fcd2bbcbdc327e1a524b825d383711536f8070c"},
	- "decimal": {:hex, :decimal, "1.8.1", "a4ef3f5f3428bdbc0d35374029ffcf4ede8533536fa79896dd450168d9acdf3c", [:mix], [], "hexpm", "3cb154b00225ac687f6cbd4acc4b7960027c757a5152b369923ead9ddbca7aec"},
	+ "decimal": {:hex, :decimal, "2.0.0", "a78296e617b0f5dd4c6caf57c714431347912ffb1d0842e998e9792b5642d697", [:mix], [], "hexpm", "34666e9c55dea81013e77d9d87370fe6cb6291d1ef32f46a1600230b1d44f577"},
	"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
	"earmark": {:hex, :earmark, "1.4.3", "364ca2e9710f6bff494117dbbd53880d84bebb692dafc3a78eb50aa3183f2bfd", [:mix], [], "hexpm", "8cf8a291ebf1c7b9539e3cddb19e9cef066c2441b1640f13c34c1d3cfc825fec"},
	"earmark_parser": {:hex, :earmark_parser, "1.4.10", "6603d7a603b9c18d3d20db69921527f82ef09990885ed7525003c7fe7dc86c56", [:mix], [], "hexpm", "8e2d5370b732385db2c9b22215c3f59c84ac7dda7ed7e544d7c459496ae519c0"},
	- "ecto": {:hex, :ecto, "3.4.5", "2bcd262f57b2c888b0bd7f7a28c8a48aa11dc1a2c6a858e45dd8f8426d504265", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "8c6d1d4d524559e9b7a062f0498e2c206122552d63eacff0a6567ffe7a8e8691"},
	+ "ecto": {:hex, :ecto, "3.4.6", "08f7afad3257d6eb8613309af31037e16c36808dfda5a3cd0cb4e9738db030e4", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6f13a9e2a62e75c2dcfc7207bfc65645ab387af8360db4c89fee8b5a4bf3f70b"},
	"ecto_enum": {:hex, :ecto_enum, "1.4.0", "d14b00e04b974afc69c251632d1e49594d899067ee2b376277efd8233027aec8", [:mix], [{:ecto, ">= 3.0.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "> 3.0.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:mariaex, ">= 0.0.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, ">= 0.0.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "8fb55c087181c2b15eee406519dc22578fa60dd82c088be376d0010172764ee4"},
	"ecto_sql": {:hex, :ecto_sql, "3.4.5", "30161f81b167d561a9a2df4329c10ae05ff36eca7ccc84628f2c8b9fa1e43323", [:mix], [{:db_connection, "~> 2.2", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.4.3", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.3.0 or ~> 0.4.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.15.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.0", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "31990c6a3579b36a3c0841d34a94c275e727de8b84f58509da5f1b2032c98ac2"},
	"eimp": {:hex, :eimp, "1.0.14", "fc297f0c7e2700457a95a60c7010a5f1dcb768a083b6d53f49cd94ab95a28f22", [:rebar3], [{:p1_utils, "1.0.18", [hex: :p1_utils, repo: "hexpm", optional: false]}], "hexpm", "501133f3112079b92d9e22da8b88bf4f0e13d4d67ae9c15c42c30bd25ceb83b6"},
	"elixir_make": {:hex, :elixir_make, "0.6.0", "38349f3e29aff4864352084fc736fa7fa0f2995a819a737554f7ebd28b85aaab", [:mix], [], "hexpm", "d522695b93b7f0b4c0fcb2dfe73a6b905b1c301226a5a55cb42e5b14d509e050"},
	"esshd": {:hex, :esshd, "0.1.1", "d4dd4c46698093a40a56afecce8a46e246eb35463c457c246dacba2e056f31b5", [:mix], [], "hexpm", "d73e341e3009d390aa36387dc8862860bf9f874c94d9fd92ade2926376f49981"},
	"eternal": {:hex, :eternal, "1.2.1", "d5b6b2499ba876c57be2581b5b999ee9bdf861c647401066d3eeed111d096bc4", [:mix], [], "hexpm", "b14f1dc204321429479c569cfbe8fb287541184ed040956c8862cb7a677b8406"},
	"ex2ms": {:hex, :ex2ms, "1.5.0", "19e27f9212be9a96093fed8cdfbef0a2b56c21237196d26760f11dfcfae58e97", [:mix], [], "hexpm"},
	"ex_aws": {:hex, :ex_aws, "2.1.3", "26b6f036f0127548706aade4a509978fc7c26bd5334b004fba9bfe2687a525df", [:mix], [{:configparser_ex, "~> 4.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:jsx, "~> 2.8", [hex: :jsx, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "0bdbe2aed9f326922fc5a6a80417e32f0c895f4b3b2b0b9676ebf23dd16c5da4"},
	"ex_aws_s3": {:hex, :ex_aws_s3, "2.0.2", "c0258bbdfea55de4f98f0b2f0ca61fe402cc696f573815134beb1866e778f47b", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "0569f5b211b1a3b12b705fe2a9d0e237eb1360b9d76298028df2346cad13097a"},
	"ex_const": {:hex, :ex_const, "0.2.4", "d06e540c9d834865b012a17407761455efa71d0ce91e5831e86881b9c9d82448", [:mix], [], "hexpm", "96fd346610cc992b8f896ed26a98be82ac4efb065a0578f334a32d60a3ba9767"},
	"ex_doc": {:hex, :ex_doc, "0.22.2", "03a2a58bdd2ba0d83d004507c4ee113b9c521956938298eba16e55cc4aba4a6c", [:mix], [{:earmark_parser, "~> 1.4.0", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm", "cf60e1b3e2efe317095b6bb79651f83a2c1b3edcb4d319c421d7fcda8b3aff26"},
	"ex_machina": {:hex, :ex_machina, "2.4.0", "09a34c5d371bfb5f78399029194a8ff67aff340ebe8ba19040181af35315eabb", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm", "a20bc9ddc721b33ea913b93666c5d0bdca5cbad7a67540784ae277228832d72c"},
	"ex_syslogger": {:hex, :ex_syslogger, "1.5.2", "72b6aa2d47a236e999171f2e1ec18698740f40af0bd02c8c650bf5f1fd1bac79", [:mix], [{:poison, ">= 1.5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:syslog, "~> 1.1.0", [hex: :syslog, repo: "hexpm", optional: false]}], "hexpm", "ab9fab4136dbc62651ec6f16fa4842f10cf02ab4433fa3d0976c01be99398399"},
	"excoveralls": {:hex, :excoveralls, "0.12.3", "2142be7cb978a3ae78385487edda6d1aff0e482ffc6123877bb7270a8ffbcfe0", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "568a3e616c264283f5dea5b020783ae40eef3f7ee2163f7a67cbd7b35bcadada"},
	"fast_html": {:hex, :fast_html, "2.0.4", "4910ee49f2f6b19692e3bf30bf97f1b6b7dac489cd6b0f34cd0fe3042c56ba30", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.1.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}], "hexpm", "3bb49d541dfc02ad5e425904f53376d758c09f89e521afc7d2b174b3227761ea"},
	"fast_sanitize": {:hex, :fast_sanitize, "0.2.2", "3cbbaebaea6043865dfb5b4ecb0f1af066ad410a51470e353714b10c42007b81", [:mix], [{:fast_html, "~> 2.0", [hex: :fast_html, repo: "hexpm", optional: false]}, {:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "69f204db9250afa94a0d559d9110139850f57de2b081719fbafa1e9a89e94466"},
	"flake_id": {:hex, :flake_id, "0.1.0", "7716b086d2e405d09b647121a166498a0d93d1a623bead243e1f74216079ccb3", [:mix], [{:base62, "~> 1.2", [hex: :base62, repo: "hexpm", optional: false]}, {:ecto, ">= 2.0.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm", "31fc8090fde1acd267c07c36ea7365b8604055f897d3a53dd967658c691bd827"},
	"floki": {:hex, :floki, "0.27.0", "6b29a14283f1e2e8fad824bc930eaa9477c462022075df6bea8f0ad811c13599", [:mix], [{:html_entities, "~> 0.5.0", [hex: :html_entities, repo: "hexpm", optional: false]}], "hexpm", "583b8c13697c37179f1f82443bcc7ad2f76fbc0bf4c186606eebd658f7f2631b"},
	"gen_smtp": {:hex, :gen_smtp, "0.15.0", "9f51960c17769b26833b50df0b96123605a8024738b62db747fece14eb2fbfcc", [:rebar3], [], "hexpm", "29bd14a88030980849c7ed2447b8db6d6c9278a28b11a44cafe41b791205440f"},
	"gen_stage": {:hex, :gen_stage, "0.14.3", "d0c66f1c87faa301c1a85a809a3ee9097a4264b2edf7644bf5c123237ef732bf", [:mix], [], "hexpm"},
	"gen_state_machine": {:hex, :gen_state_machine, "2.0.5", "9ac15ec6e66acac994cc442dcc2c6f9796cf380ec4b08267223014be1c728a95", [:mix], [], "hexpm"},
	"gettext": {:hex, :gettext, "0.18.0", "406d6b9e0e3278162c2ae1de0a60270452c553536772167e2d701f028116f870", [:mix], [], "hexpm", "c3f850be6367ebe1a08616c2158affe4a23231c70391050bf359d5f92f66a571"},
	"gun": {:git, "https://github.com/ninenines/gun.git", "921c47146b2d9567eac7e9a4d2ccc60fffd4f327", [ref: "921c47146b2d9567eac7e9a4d2ccc60fffd4f327"]},
	"hackney": {:hex, :hackney, "1.15.2", "07e33c794f8f8964ee86cebec1a8ed88db5070e52e904b8f12209773c1036085", [:rebar3], [{:certifi, "2.5.1", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "6.0.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "1.0.1", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "1.1.5", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm", "e0100f8ef7d1124222c11ad362c857d3df7cb5f4204054f9f0f4a728666591fc"},
	"html_entities": {:hex, :html_entities, "0.5.1", "1c9715058b42c35a2ab65edc5b36d0ea66dd083767bef6e3edb57870ef556549", [:mix], [], "hexpm", "30efab070904eb897ff05cd52fa61c1025d7f8ef3a9ca250bc4e6513d16c32de"},
	"html_sanitize_ex": {:hex, :html_sanitize_ex, "1.3.0", "f005ad692b717691203f940c686208aa3d8ffd9dd4bb3699240096a51fa9564e", [:mix], [{:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
	"http_signatures": {:hex, :http_signatures, "0.1.0", "4e4b501a936dbf4cb5222597038a89ea10781776770d2e185849fa829686b34c", [:mix], [], "hexpm", "f8a7b3731e3fd17d38fa6e343fcad7b03d6874a3b0a108c8568a71ed9c2cf824"},
	"httpoison": {:hex, :httpoison, "1.6.2", "ace7c8d3a361cebccbed19c283c349b3d26991eff73a1eaaa8abae2e3c8089b6", [:mix], [{:hackney, "~> 1.15 and >= 1.15.2", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "aa2c74bd271af34239a3948779612f87df2422c2fdcfdbcec28d9c105f0773fe"},
	"idna": {:hex, :idna, "6.0.0", "689c46cbcdf3524c44d5f3dde8001f364cd7608a99556d8fbd8239a5798d4c10", [:rebar3], [{:unicode_util_compat, "0.4.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "4bdd305eb64e18b0273864920695cb18d7a2021f31a11b9c5fbcd9a253f936e2"},
	"inet_cidr": {:hex, :inet_cidr, "1.0.4", "a05744ab7c221ca8e395c926c3919a821eb512e8f36547c062f62c4ca0cf3d6e", [:mix], [], "hexpm", "64a2d30189704ae41ca7dbdd587f5291db5d1dda1414e0774c29ffc81088c1bc"},
	- "jason": {:hex, :jason, "1.2.1", "12b22825e22f468c02eb3e4b9985f3d0cb8dc40b9bd704730efa11abd2708c44", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "b659b8571deedf60f79c5a608e15414085fa141344e2716fbd6988a084b5f993"},
	+ "jason": {:hex, :jason, "1.2.2", "ba43e3f2709fd1aa1dce90aaabfd039d000469c05c56f0b8e31978e03fa39052", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "18a228f5f0058ee183f29f9eae0805c6e59d61c3b006760668d8d18ff0d12179"},
	"joken": {:hex, :joken, "2.2.0", "2daa1b12be05184aff7b5ace1d43ca1f81345962285fff3f88db74927c954d3a", [:mix], [{:jose, "~> 1.9", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "b4f92e30388206f869dd25d1af628a1d99d7586e5cf0672f64d4df84c4d2f5e9"},
	"jose": {:hex, :jose, "1.10.1", "16d8e460dae7203c6d1efa3f277e25b5af8b659febfc2f2eb4bacf87f128b80a", [:mix, :rebar3], [], "hexpm", "3c7ddc8a9394b92891db7c2771da94bf819834a1a4c92e30857b7d582e2f8257"},
	"jumper": {:hex, :jumper, "1.0.1", "3c00542ef1a83532b72269fab9f0f0c82bf23a35e27d278bfd9ed0865cecabff", [:mix], [], "hexpm", "318c59078ac220e966d27af3646026db9b5a5e6703cb2aa3e26bcfaba65b7433"},
	"libring": {:hex, :libring, "1.4.0", "41246ba2f3fbc76b3971f6bce83119dfec1eee17e977a48d8a9cfaaf58c2a8d6", [:mix], [], "hexpm"},
	"linkify": {:hex, :linkify, "0.2.0", "2518bbbea21d2caa9d372424e1ad845b640c6630e2d016f1bd1f518f9ebcca28", [:mix], [], "hexpm", "b8ca8a68b79e30b7938d6c996085f3db14939f29538a59ca5101988bb7f917f6"},
	"makeup": {:hex, :makeup, "1.0.3", "e339e2f766d12e7260e6672dd4047405963c5ec99661abdc432e6ec67d29ef95", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "2e9b4996d11832947731f7608fed7ad2f9443011b3b479ae288011265cdd3dad"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.14.1", "4f0e96847c63c17841d42c08107405a005a2680eb9c7ccadfd757bd31dabccfb", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f2438b1a80eaec9ede832b5c41cd4f373b38fd7aa33e3b22d9db79e640cbde11"},
	"meck": {:hex, :meck, "0.8.13", "ffedb39f99b0b99703b8601c6f17c7f76313ee12de6b646e671e3188401f7866", [:rebar3], [], "hexpm", "d34f013c156db51ad57cc556891b9720e6a1c1df5fe2e15af999c84d6cebeb1a"},
	"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},
	"mime": {:hex, :mime, "1.4.0", "5066f14944b470286146047d2f73518cf5cca82f8e4815cf35d196b58cf07c47", [:mix], [], "hexpm", "75fa42c4228ea9a23f70f123c74ba7cece6a03b1fd474fe13f6a7a85c6ea4ff6"},
	"mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm", "f278585650aa581986264638ebf698f8bb19df297f66ad91b18910dfc6e19323"},
	"mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.5", "feb81f52b8dcf0a0d65001d2fec459f6b6a8c22562d94a965862f6cc066b5431", [:mix], [{:meck, "~> 0.8.13", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm", "6fae404799408300f863550392635d8f7e3da6b71abdd5c393faf41b131c8728"},
	"mogrify": {:hex, :mogrify, "0.7.4", "9b2496dde44b1ce12676f85d7dc531900939e6367bc537c7243a1b089435b32d", [:mix], [], "hexpm", "50d79e337fba6bc95bfbef918058c90f50b17eed9537771e61d4619488f099c3"},
	"mox": {:hex, :mox, "0.5.2", "55a0a5ba9ccc671518d068c8dddd20eeb436909ea79d1799e2209df7eaa98b6c", [:mix], [], "hexpm", "df4310628cd628ee181df93f50ddfd07be3e5ecc30232d3b6aadf30bdfe6092b"},
	"myhtmlex": {:git, "https://git.pleroma.social/pleroma/myhtmlex.git", "ad0097e2f61d4953bfef20fb6abddf23b87111e6", [ref: "ad0097e2f61d4953bfef20fb6abddf23b87111e6", submodules: true]},
	"nimble_parsec": {:hex, :nimble_parsec, "0.6.0", "32111b3bf39137144abd7ba1cce0914533b2d16ef35e8abc5ec8be6122944263", [:mix], [], "hexpm", "27eac315a94909d4dc68bc07a4a83e06c8379237c5ea528a9acff4ca1c873c52"},
	"nimble_pool": {:hex, :nimble_pool, "0.1.0", "ffa9d5be27eee2b00b0c634eb649aa27f97b39186fec3c493716c2a33e784ec6", [:mix], [], "hexpm", "343a1eaa620ddcf3430a83f39f2af499fe2370390d4f785cd475b4df5acaf3f9"},
	"nodex": {:git, "https://git.pleroma.social/pleroma/nodex", "cb6730f943cfc6aad674c92161be23a8411f15d1", [ref: "cb6730f943cfc6aad674c92161be23a8411f15d1"]},
	- "oban": {:hex, :oban, "2.0.0", "e6ce70d94dd46815ec0882a1ffb7356df9a9d5b8a40a64ce5c2536617a447379", [:mix], [{:ecto_sql, ">= 3.4.3", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.14", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "cf574813bd048b98a698aa587c21367d2e06842d4e1b1993dcd6a696e9e633bd"},
	+ "oban": {:hex, :oban, "2.1.0", "034144686f7e76a102b5d67731f098d98a9e4a52b07c25ad580a01f83a7f1cf5", [:mix], [{:ecto_sql, ">= 3.4.3", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.14", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c6f067fa3b308ed9e0e6beb2b34277c9c4e48bf95338edabd8f4a757a26e04c2"},
	"open_api_spex": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/open_api_spex.git", "f296ac0924ba3cf79c7a588c4c252889df4c2edd", [ref: "f296ac0924ba3cf79c7a588c4c252889df4c2edd"]},
	"p1_utils": {:hex, :p1_utils, "1.0.18", "3fe224de5b2e190d730a3c5da9d6e8540c96484cf4b4692921d1e28f0c32b01c", [:rebar3], [], "hexpm", "1fc8773a71a15553b179c986b22fbeead19b28fe486c332d4929700ffeb71f88"},
	"parse_trans": {:hex, :parse_trans, "3.3.0", "09765507a3c7590a784615cfd421d101aec25098d50b89d7aa1d66646bc571c1", [:rebar3], [], "hexpm", "17ef63abde837ad30680ea7f857dd9e7ced9476cdd7b0394432af4bfc241b960"},
	"pbkdf2_elixir": {:hex, :pbkdf2_elixir, "1.2.1", "9cbe354b58121075bd20eb83076900a3832324b7dd171a6895fab57b6bb2752c", [:mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}], "hexpm", "d3b40a4a4630f0b442f19eca891fcfeeee4c40871936fed2f68e1c4faa30481f"},
	"phoenix": {:hex, :phoenix, "1.4.17", "1b1bd4cff7cfc87c94deaa7d60dd8c22e04368ab95499483c50640ef3bd838d8", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.8.1 or ~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3a8e5d7a3d76d452bb5fb86e8b7bd115f737e4f8efe202a463d4aeb4a5809611"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "4.1.0", "a044d0756d0464c5a541b4a0bf4bcaf89bffcaf92468862408290682c73ae50d", [:mix], [{:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "c5e666a341ff104d0399d8f0e4ff094559b2fde13a5985d4cb5023b2c2ac558b"},
	"phoenix_html": {:hex, :phoenix_html, "2.14.2", "b8a3899a72050f3f48a36430da507dd99caf0ac2d06c77529b1646964f3d563e", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "58061c8dfd25da5df1ea0ca47c972f161beb6c875cd293917045b92ffe1bf617"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "1.1.2", "496c303bdf1b2e98a9d26e89af5bba3ab487ba3a3735f74bf1f4064d2a845a3e", [:mix], [], "hexpm", "1f13f9f0f3e769a667a6b6828d29dec37497a082d195cc52dbef401a9b69bf38"},
	"phoenix_swoosh": {:hex, :phoenix_swoosh, "0.3.0", "2acfa0db038a7649e0a4614eee970e6ed9a39d191ccd79a03583b51d0da98165", [:mix], [{:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:swoosh, "~> 1.0", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm", "b8bbae4b59a676de6b8bd8675eda37bc8b4424812ae429d6fdcb2b039e00003b"},
	"plug": {:hex, :plug, "1.10.4", "41eba7d1a2d671faaf531fa867645bd5a3dce0957d8e2a3f398ccff7d2ef017f", [:mix], [{:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ad1e233fe73d2eec56616568d260777b67f53148a999dc2d048f4eb9778fe4a0"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.3.0", "149a50e05cb73c12aad6506a371cd75750c0b19a32f81866e1a323dda9e0e99d", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "bc595a1870cef13f9c1e03df56d96804db7f702175e4ccacdb8fc75c02a7b97e"},
	"plug_crypto": {:hex, :plug_crypto, "1.1.2", "bdd187572cc26dbd95b87136290425f2b580a116d3fb1f564216918c9730d227", [:mix], [], "hexpm", "6b8b608f895b6ffcfad49c37c7883e8df98ae19c6a28113b02aa1e9c5b22d6b5"},
	"plug_static_index_html": {:hex, :plug_static_index_html, "1.0.0", "840123d4d3975585133485ea86af73cb2600afd7f2a976f9f5fd8b3808e636a0", [:mix], [{:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "79fd4fcf34d110605c26560cbae8f23c603ec4158c08298bd4360fdea90bb5cf"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm", "fec8660eb7733ee4117b85f55799fd3833eb769a6df71ccf8903e8dc5447cfce"},
	"poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm", "dad79704ce5440f3d5a3681c8590b9dc25d1a561e8f5a9c995281012860901e3"},
	- "postgrex": {:hex, :postgrex, "0.15.5", "aec40306a622d459b01bff890fa42f1430dac61593b122754144ad9033a2152f", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "ed90c81e1525f65a2ba2279dbcebf030d6d13328daa2f8088b9661eb9143af7f"},
	+ "postgrex": {:hex, :postgrex, "0.15.6", "a464c72010a56e3214fe2b99c1a76faab4c2bb0255cabdef30dea763a3569aa2", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "f99268325ac8f66ffd6c4964faab9e70fbf721234ab2ad238c00f9530b8cdd55"},
	"pot": {:hex, :pot, "0.11.0", "61bad869a94534739dd4614a25a619bc5c47b9970e9a0ea5bef4628036fc7a16", [:rebar3], [], "hexpm", "57ee6ee6bdeb639661ffafb9acefe3c8f966e45394de6a766813bb9e1be4e54b"},
	"prometheus": {:hex, :prometheus, "4.6.0", "20510f381db1ccab818b4cf2fac5fa6ab5cc91bc364a154399901c001465f46f", [:mix, :rebar3], [], "hexpm", "4905fd2992f8038eccd7aa0cd22f40637ed618c0bed1f75c05aacec15b7545de"},
	"prometheus_ecto": {:hex, :prometheus_ecto, "1.4.3", "3dd4da1812b8e0dbee81ea58bb3b62ed7588f2eae0c9e97e434c46807ff82311", [:mix], [{:ecto, "~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "8d66289f77f913b37eda81fd287340c17e61a447549deb28efc254532b2bed82"},
	"prometheus_ex": {:hex, :prometheus_ex, "3.0.5", "fa58cfd983487fc5ead331e9a3e0aa622c67232b3ec71710ced122c4c453a02f", [:mix], [{:prometheus, "~> 4.0", [hex: :prometheus, repo: "hexpm", optional: false]}], "hexpm", "9fd13404a48437e044b288b41f76e64acd9735fb8b0e3809f494811dfa66d0fb"},
	"prometheus_phoenix": {:hex, :prometheus_phoenix, "1.3.0", "c4b527e0b3a9ef1af26bdcfbfad3998f37795b9185d475ca610fe4388fdd3bb5", [:mix], [{:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.3 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "c4d1404ac4e9d3d963da601db2a7d8ea31194f0017057fabf0cfb9bf5a6c8c75"},
	"prometheus_plugs": {:hex, :prometheus_plugs, "1.1.5", "25933d48f8af3a5941dd7b621c889749894d8a1082a6ff7c67cc99dec26377c5", [:mix], [{:accept, "~> 0.1", [hex: :accept, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}, {:prometheus_process_collector, "~> 1.1", [hex: :prometheus_process_collector, repo: "hexpm", optional: true]}], "hexpm", "0273a6483ccb936d79ca19b0ab629aef0dba958697c94782bb728b920dfc6a79"},
	"quack": {:hex, :quack, "0.1.1", "cca7b4da1a233757fdb44b3334fce80c94785b3ad5a602053b7a002b5a8967bf", [:mix], [{:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: false]}, {:tesla, "~> 1.2.0", [hex: :tesla, repo: "hexpm", optional: false]}], "hexpm", "d736bfa7444112eb840027bb887832a0e403a4a3437f48028c3b29a2dbbd2543"},
	"ranch": {:hex, :ranch, "1.7.1", "6b1fab51b49196860b733a49c07604465a47bdb78aa10c1c16a3d199f7f8c881", [:rebar3], [], "hexpm", "451d8527787df716d99dc36162fca05934915db0b6141bbdac2ea8d3c7afc7d7"},
	"recon": {:hex, :recon, "2.5.1", "430ffa60685ac1efdfb1fe4c97b8767c92d0d92e6e7c3e8621559ba77598678a", [:mix, :rebar3], [], "hexpm", "5721c6b6d50122d8f68cccac712caa1231f97894bab779eff5ff0f886cb44648"},
	"remote_ip": {:git, "https://git.pleroma.social/pleroma/remote_ip.git", "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8", [ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"]},
	"sleeplocks": {:hex, :sleeplocks, "1.1.1", "3d462a0639a6ef36cc75d6038b7393ae537ab394641beb59830a1b8271faeed3", [:rebar3], [], "hexpm", "84ee37aeff4d0d92b290fff986d6a95ac5eedf9b383fadfd1d88e9b84a1c02e1"},
	"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.5", "6eaf7ad16cb568bb01753dbbd7a95ff8b91c7979482b95f38443fe2c8852a79b", [:make, :mix, :rebar3], [], "hexpm", "13104d7897e38ed7f044c4de953a6c28597d1c952075eb2e328bc6d6f2bfc496"},
	"sweet_xml": {:hex, :sweet_xml, "0.6.6", "fc3e91ec5dd7c787b6195757fbcf0abc670cee1e4172687b45183032221b66b8", [:mix], [], "hexpm", "2e1ec458f892ffa81f9f8386e3f35a1af6db7a7a37748a64478f13163a1f3573"},
	"swoosh": {:hex, :swoosh, "1.0.0", "c547cfc83f30e12d5d1fdcb623d7de2c2e29a5becfc68bf8f42ba4d23d2c2756", [:mix], [{:cowboy, "~> 1.0.1 or ~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}], "hexpm", "b3b08e463f876cb6167f7168e9ad99a069a724e124bcee61847e0e1ed13f4a0d"},
	"syslog": {:hex, :syslog, "1.1.0", "6419a232bea84f07b56dc575225007ffe34d9fdc91abe6f1b2f254fd71d8efc2", [:rebar3], [], "hexpm", "4c6a41373c7e20587be33ef841d3de6f3beba08519809329ecc4d27b15b659e1"},
	"telemetry": {:hex, :telemetry, "0.4.2", "2808c992455e08d6177322f14d3bdb6b625fbcfd233a73505870d8738a2f4599", [:rebar3], [], "hexpm", "2d1419bd9dda6a206d7b5852179511722e2b18812310d304620c7bd92a13fcef"},
	"tesla": {:git, "https://github.com/teamon/tesla/", "9f7261ca49f9f901ceb73b60219ad6f8a9f6aa30", [ref: "9f7261ca49f9f901ceb73b60219ad6f8a9f6aa30"]},
	"timex": {:hex, :timex, "3.6.2", "845cdeb6119e2fef10751c0b247b6c59d86d78554c83f78db612e3290f819bc2", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 0.1.8 or ~> 0.5 or ~> 1.0.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "26030b46199d02a590be61c2394b37ea25a3664c02fafbeca0b24c972025d47a"},
	"trailing_format_plug": {:hex, :trailing_format_plug, "0.0.7", "64b877f912cf7273bed03379936df39894149e35137ac9509117e59866e10e45", [:mix], [{:plug, "> 0.12.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "bd4fde4c15f3e993a999e019d64347489b91b7a9096af68b2bdadd192afa693f"},
	"tzdata": {:hex, :tzdata, "1.0.3", "73470ad29dde46e350c60a66e6b360d3b99d2d18b74c4c349dbebbc27a09a3eb", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "a6e1ee7003c4d04ecbd21dd3ec690d4c6662db5d3bbdd7262d53cdf5e7c746c1"},
	"ueberauth": {:hex, :ueberauth, "0.6.3", "d42ace28b870e8072cf30e32e385579c57b9cc96ec74fa1f30f30da9c14f3cc0", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "afc293d8a1140d6591b53e3eaf415ca92842cb1d32fad3c450c6f045f7f91b60"},
	"unicode_util_compat": {:hex, :unicode_util_compat, "0.4.1", "d869e4c68901dd9531385bb0c8c40444ebf624e60b6962d95952775cac5e90cd", [:rebar3], [], "hexpm", "1d1848c40487cdb0b30e8ed975e34e025860c02e419cb615d255849f3427439d"},
	"unsafe": {:hex, :unsafe, "1.0.1", "a27e1874f72ee49312e0a9ec2e0b27924214a05e3ddac90e91727bc76f8613d8", [:mix], [], "hexpm", "6c7729a2d214806450d29766abc2afaa7a2cbecf415be64f36a6691afebb50e5"},
	"web_push_encryption": {:hex, :web_push_encryption, "0.3.0", "598b5135e696fd1404dc8d0d7c0fa2c027244a4e5d5e5a98ba267f14fdeaabc8", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.8", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "f10bdd1afe527ede694749fb77a2f22f146a51b054c7fa541c9fd920fba7c875"},
	- "websocket_client": {:git, "https://github.com/jeremyong/websocket_client.git", "9a6f65d05ebf2725d62fb19262b21f1805a59fbf", []}
	+ "websocket_client": {:git, "https://github.com/jeremyong/websocket_client.git", "9a6f65d05ebf2725d62fb19262b21f1805a59fbf", []},
	}
	diff --git a/priv/repo/migrations/20200928145912_revert_citext_change.exs b/priv/repo/migrations/20200928145912_revert_citext_change.exs
	index ab232f607..685a98533 100644
	--- a/priv/repo/migrations/20200928145912_revert_citext_change.exs
	+++ b/priv/repo/migrations/20200928145912_revert_citext_change.exs
	@@ -1,11 +1,11 @@
	defmodule Pleroma.Repo.Migrations.RevertCitextChange do
	use Ecto.Migration

	def change do
	alter table(:users) do
	modify(:uri, :text)
	end

	- create_if_not_exists(unique_index(:users, :uri))
	+ # create_if_not_exists(unique_index(:users, :uri))
	end
	end
	diff --git a/priv/repo/migrations/20200930082320_user_ur_is_index_part_three.exs b/priv/repo/migrations/20200930082320_user_ur_is_index_part_three.exs
	new file mode 100644
	index 000000000..816c6526e
	--- /dev/null
	+++ b/priv/repo/migrations/20200930082320_user_ur_is_index_part_three.exs
	@@ -0,0 +1,8 @@
	+defmodule Pleroma.Repo.Migrations.UserURIsIndexPartThree do
	+ use Ecto.Migration
	+
	+ def change do
	+ drop_if_exists(unique_index(:users, :uri))
	+ create_if_not_exists(index(:users, :uri))
	+ end
	+end
	diff --git a/test/instance_static/emoji/blobs.gg/blank.png b/test/instance_static/emoji/blobs.gg/blank.png
	new file mode 100644
	index 000000000..8f50fa023
	Binary files /dev/null and b/test/instance_static/emoji/blobs.gg/blank.png differ
	diff --git a/test/instance_static/emoji/blobs.gg/pack.json b/test/instance_static/emoji/blobs.gg/pack.json
	new file mode 100644
	index 000000000..481891b08
	--- /dev/null
	+++ b/test/instance_static/emoji/blobs.gg/pack.json
	@@ -0,0 +1,11 @@
	+{
	+ "files": {
	+ "blank": "blank.png"
	+ },
	+ "pack": {
	+ "description": "Test description",
	+ "homepage": "https://pleroma.social",
	+ "license": "Test license",
	+ "share-files": true
	+ }
	+}
	\ No newline at end of file
	diff --git a/test/support/web_push_http_client_mock.ex b/test/support/web_push_http_client_mock.ex
	deleted file mode 100644
	index 3cd12957d..000000000
	--- a/test/support/web_push_http_client_mock.ex
	+++ /dev/null
	@@ -1,23 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Pleroma.Web.WebPushHttpClientMock do
	- def get(url, headers \\ [], options \\ []) do
	- {
	- res,
	- %Tesla.Env{status: status}
	- } = Pleroma.HTTP.request(:get, url, "", headers, options)
	-
	- {res, %{status_code: status}}
	- end
	-
	- def post(url, body, headers \\ [], options \\ []) do
	- {
	- res,
	- %Tesla.Env{status: status}
	- } = Pleroma.HTTP.request(:post, url, body, headers, options)
	-
	- {res, %{status_code: status}}
	- end
	-end
	diff --git a/test/tasks/relay_test.exs b/test/tasks/relay_test.exs
	index e5225b64c..cf48e7dda 100644
	--- a/test/tasks/relay_test.exs
	+++ b/test/tasks/relay_test.exs
	@@ -1,106 +1,180 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.RelayTest do
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	use Pleroma.DataCase

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)

	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "running follow" do
	test "relay is followed" do
	target_instance = "http://mastodon.example.org/users/admin"

	Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])

	local_user = Relay.get_actor()
	assert local_user.ap_id =~ "/relay"

	target_user = User.get_cached_by_ap_id(target_instance)
	refute target_user.local

	activity = Utils.fetch_latest_follow(local_user, target_user)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == local_user.ap_id
	assert activity.data["object"] == target_user.ap_id

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])

	assert_receive {:mix_shell, :info,
	[
	"http://mastodon.example.org/users/admin - no Accept received (relay didn't follow back)"
	]}
	end
	end

	describe "running unfollow" do
	test "relay is unfollowed" do
	user = insert(:user)
	target_instance = user.ap_id

	Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])

	%User{ap_id: follower_id} = local_user = Relay.get_actor()
	target_user = User.get_cached_by_ap_id(target_instance)
	follow_activity = Utils.fetch_latest_follow(local_user, target_user)
	User.follow(local_user, target_user)
	assert "#{target_instance}/followers" in User.following(local_user)
	Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance])

	cancelled_activity = Activity.get_by_ap_id(follow_activity.data["id"])
	assert cancelled_activity.data["state"] == "cancelled"

	[undo_activity] =
	ActivityPub.fetch_activities([], %{
	type: "Undo",
	actor_id: follower_id,
	limit: 1,
	skip_preload: true,
	invisible_actors: true
	})

	assert undo_activity.data["type"] == "Undo"
	assert undo_activity.data["actor"] == local_user.ap_id
	assert undo_activity.data["object"]["id"] == cancelled_activity.data["id"]
	refute "#{target_instance}/followers" in User.following(local_user)
	end
	+
	+ test "unfollow when relay is dead" do
	+ user = insert(:user)
	+ target_instance = user.ap_id
	+
	+ Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])
	+
	+ %User{ap_id: follower_id} = local_user = Relay.get_actor()
	+ target_user = User.get_cached_by_ap_id(target_instance)
	+ follow_activity = Utils.fetch_latest_follow(local_user, target_user)
	+ User.follow(local_user, target_user)
	+
	+ assert "#{target_instance}/followers" in User.following(local_user)
	+
	+ Tesla.Mock.mock(fn %{method: :get, url: ^target_instance} ->
	+ %Tesla.Env{status: 404}
	+ end)
	+
	+ Pleroma.Repo.delete(user)
	+ Cachex.clear(:user_cache)
	+
	+ Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance])
	+
	+ cancelled_activity = Activity.get_by_ap_id(follow_activity.data["id"])
	+ assert cancelled_activity.data["state"] == "accept"
	+
	+ assert [] ==
	+ ActivityPub.fetch_activities(
	+ [],
	+ %{
	+ type: "Undo",
	+ actor_id: follower_id,
	+ skip_preload: true,
	+ invisible_actors: true
	+ }
	+ )
	+ end
	+
	+ test "force unfollow when relay is dead" do
	+ user = insert(:user)
	+ target_instance = user.ap_id
	+
	+ Mix.Tasks.Pleroma.Relay.run(["follow", target_instance])
	+
	+ %User{ap_id: follower_id} = local_user = Relay.get_actor()
	+ target_user = User.get_cached_by_ap_id(target_instance)
	+ follow_activity = Utils.fetch_latest_follow(local_user, target_user)
	+ User.follow(local_user, target_user)
	+
	+ assert "#{target_instance}/followers" in User.following(local_user)
	+
	+ Tesla.Mock.mock(fn %{method: :get, url: ^target_instance} ->
	+ %Tesla.Env{status: 404}
	+ end)
	+
	+ Pleroma.Repo.delete(user)
	+ Cachex.clear(:user_cache)
	+
	+ Mix.Tasks.Pleroma.Relay.run(["unfollow", target_instance, "--force"])
	+
	+ cancelled_activity = Activity.get_by_ap_id(follow_activity.data["id"])
	+ assert cancelled_activity.data["state"] == "cancelled"
	+
	+ [undo_activity] =
	+ ActivityPub.fetch_activities(
	+ [],
	+ %{type: "Undo", actor_id: follower_id, skip_preload: true, invisible_actors: true}
	+ )
	+
	+ assert undo_activity.data["type"] == "Undo"
	+ assert undo_activity.data["actor"] == local_user.ap_id
	+ assert undo_activity.data["object"]["id"] == cancelled_activity.data["id"]
	+ refute "#{target_instance}/followers" in User.following(local_user)
	+ end
	end

	describe "mix pleroma.relay list" do
	test "Prints relay subscription list" do
	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])

	refute_receive {:mix_shell, :info, _}

	relay_user = 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)

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])

	assert_receive {:mix_shell, :info, ["https://mstdn.io/users/mayuutann"]}
	assert_receive {:mix_shell, :info, ["http://mastodon.example.org/users/admin"]}
	end
	end
	end
	diff --git a/test/user_search_test.exs b/test/user_search_test.exs
	index cc14e9741..c4b805005 100644
	--- a/test/user_search_test.exs
	+++ b/test/user_search_test.exs
	@@ -1,356 +1,362 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserSearchTest do
	alias Pleroma.Repo
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "User.search" do
	setup do: clear_config([:instance, :limit_to_local_content])

	test "returns a resolved user as the first result" do
	Pleroma.Config.put([:instance, :limit_to_local_content], false)
	user = insert(:user, %{nickname: "no_relation", ap_id: "https://lain.com/users/lain"})
	_user = insert(:user, %{nickname: "com_user"})

	[first_user, _second_user] = User.search("https://lain.com/users/lain", resolve: true)

	assert first_user.id == user.id
	end

	test "returns a user with matching ap_id as the first result" do
	user = insert(:user, %{nickname: "no_relation", ap_id: "https://lain.com/users/lain"})
	_user = insert(:user, %{nickname: "com_user"})

	[first_user, _second_user] = User.search("https://lain.com/users/lain")

	assert first_user.id == user.id
	end

	+ test "doesn't die if two users have the same uri" do
	+ insert(:user, %{uri: "https://gensokyo.2hu/@raymoo"})
	+ insert(:user, %{uri: "https://gensokyo.2hu/@raymoo"})
	+ assert [_first_user, _second_user] = User.search("https://gensokyo.2hu/@raymoo")
	+ end
	+
	test "returns a user with matching uri as the first result" do
	user =
	insert(:user, %{
	nickname: "no_relation",
	ap_id: "https://lain.com/users/lain",
	uri: "https://lain.com/@lain"
	})

	_user = insert(:user, %{nickname: "com_user"})

	[first_user, _second_user] = User.search("https://lain.com/@lain")

	assert first_user.id == user.id
	end

	test "excludes invisible users from results" do
	user = insert(:user, %{nickname: "john t1000"})
	insert(:user, %{invisible: true, nickname: "john t800"})

	[found_user] = User.search("john")
	assert found_user.id == user.id
	end

	test "excludes users when discoverable is false" do
	insert(:user, %{nickname: "john 3000", discoverable: false})
	insert(:user, %{nickname: "john 3001"})

	users = User.search("john")
	assert Enum.count(users) == 1
	end

	test "excludes service actors from results" do
	insert(:user, actor_type: "Application", nickname: "user1")
	service = insert(:user, actor_type: "Service", nickname: "user2")
	person = insert(:user, actor_type: "Person", nickname: "user3")

	assert [found_user1, found_user2] = User.search("user")
	assert [found_user1.id, found_user2.id] -- [service.id, person.id] == []
	end

	test "accepts limit parameter" do
	Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
	assert length(User.search("john", limit: 3)) == 3
	assert length(User.search("john")) == 5
	end

	test "accepts offset parameter" do
	Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
	assert length(User.search("john", limit: 3)) == 3
	assert length(User.search("john", limit: 3, offset: 3)) == 2
	end

	defp clear_virtual_fields(user) do
	Map.merge(user, %{search_rank: nil, search_type: nil})
	end

	test "finds a user by full nickname or its leading fragment" do
	user = insert(:user, %{nickname: "john"})

	Enum.each(["john", "jo", "j"], fn query ->
	assert user ==
	User.search(query)
	\|> List.first()
	\|> clear_virtual_fields()
	end)
	end

	test "finds a user by full name or leading fragment(s) of its words" do
	user = insert(:user, %{name: "John Doe"})

	Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
	assert user ==
	User.search(query)
	\|> List.first()
	\|> clear_virtual_fields()
	end)
	end

	test "matches by leading fragment of user domain" do
	user = insert(:user, %{nickname: "arandom@dude.com"})
	insert(:user, %{nickname: "iamthedude"})

	assert [user.id] == User.search("dud") \|> Enum.map(& &1.id)
	end

	test "ranks full nickname match higher than full name match" do
	nicknamed_user = insert(:user, %{nickname: "hj@shigusegubu.club"})
	named_user = insert(:user, %{nickname: "xyz@sample.com", name: "HJ"})

	results = User.search("hj")

	assert [nicknamed_user.id, named_user.id] == Enum.map(results, & &1.id)
	assert Enum.at(results, 0).search_rank > Enum.at(results, 1).search_rank
	end

	test "finds users, considering density of matched tokens" do
	u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
	u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})

	assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
	end

	test "finds users, boosting ranks of friends and followers" do
	u1 = insert(:user)
	u2 = insert(:user, %{name: "Doe"})
	follower = insert(:user, %{name: "Doe"})
	friend = insert(:user, %{name: "Doe"})

	{:ok, follower} = User.follow(follower, u1)
	{:ok, u1} = User.follow(u1, friend)

	assert [friend.id, follower.id, u2.id] --
	Enum.map(User.search("doe", resolve: false, for_user: u1), & &1.id) == []
	end

	test "finds followings of user by partial name" do
	lizz = insert(:user, %{name: "Lizz"})
	jimi = insert(:user, %{name: "Jimi"})
	following_lizz = insert(:user, %{name: "Jimi Hendrix"})
	following_jimi = insert(:user, %{name: "Lizz Wright"})
	follower_lizz = insert(:user, %{name: "Jimi"})

	{:ok, lizz} = User.follow(lizz, following_lizz)
	{:ok, _jimi} = User.follow(jimi, following_jimi)
	{:ok, _follower_lizz} = User.follow(follower_lizz, lizz)

	assert Enum.map(User.search("jimi", following: true, for_user: lizz), & &1.id) == [
	following_lizz.id
	]

	assert User.search("lizz", following: true, for_user: lizz) == []
	end

	test "find local and remote users for authenticated users" do
	u1 = insert(:user, %{name: "lain"})
	u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
	u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})

	results =
	"lain"
	\|> User.search(for_user: u1)
	\|> Enum.map(& &1.id)
	\|> Enum.sort()

	assert [u1.id, u2.id, u3.id] == results
	end

	test "find only local users for unauthenticated users" do
	%{id: id} = insert(:user, %{name: "lain"})
	insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
	insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})

	assert [%{id: ^id}] = User.search("lain")
	end

	test "find only local users for authenticated users when `limit_to_local_content` is `:all`" do
	Pleroma.Config.put([:instance, :limit_to_local_content], :all)

	%{id: id} = insert(:user, %{name: "lain"})
	insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
	insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})

	assert [%{id: ^id}] = User.search("lain")
	end

	test "find all users for unauthenticated users when `limit_to_local_content` is `false`" do
	Pleroma.Config.put([:instance, :limit_to_local_content], false)

	u1 = insert(:user, %{name: "lain"})
	u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
	u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})

	results =
	"lain"
	\|> User.search()
	\|> Enum.map(& &1.id)
	\|> Enum.sort()

	assert [u1.id, u2.id, u3.id] == results
	end

	test "does not yield false-positive matches" do
	insert(:user, %{name: "John Doe"})

	Enum.each(["mary", "a", ""], fn query ->
	assert [] == User.search(query)
	end)
	end

	test "works with URIs" do
	user = insert(:user)

	results =
	User.search("http://mastodon.example.org/users/admin", resolve: true, for_user: user)

	result = results \|> List.first()

	user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")

	assert length(results) == 1

	expected =
	result
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	\|> Map.put(:last_digest_emailed_at, nil)
	\|> Map.put(:multi_factor_authentication_settings, nil)
	\|> Map.put(:notification_settings, nil)

	assert user == expected
	end

	test "excludes a blocked users from search result" do
	user = insert(:user, %{nickname: "Bill"})

	[blocked_user \| users] = Enum.map(0..3, &insert(:user, %{nickname: "john#{&1}"}))

	blocked_user2 =
	insert(
	:user,
	%{nickname: "john awful", ap_id: "https://awful-and-rude-instance.com/user/bully"}
	)

	User.block_domain(user, "awful-and-rude-instance.com")
	User.block(user, blocked_user)

	account_ids = User.search("john", for_user: refresh_record(user)) \|> collect_ids

	assert account_ids == collect_ids(users)
	refute Enum.member?(account_ids, blocked_user.id)
	refute Enum.member?(account_ids, blocked_user2.id)
	assert length(account_ids) == 3
	end

	test "local user has the same search_rank as for users with the same nickname, but another domain" do
	user = insert(:user)
	insert(:user, nickname: "lain@mastodon.social")
	insert(:user, nickname: "lain")
	insert(:user, nickname: "lain@pleroma.social")

	assert User.search("lain@localhost", resolve: true, for_user: user)
	\|> Enum.each(fn u -> u.search_rank == 0.5 end)
	end

	test "localhost is the part of the domain" do
	user = insert(:user)
	insert(:user, nickname: "another@somedomain")
	insert(:user, nickname: "lain")
	insert(:user, nickname: "lain@examplelocalhost")

	result = User.search("lain@examplelocalhost", resolve: true, for_user: user)
	assert Enum.each(result, fn u -> u.search_rank == 0.5 end)
	assert length(result) == 2
	end

	test "local user search with users" do
	user = insert(:user)
	local_user = insert(:user, nickname: "lain")
	insert(:user, nickname: "another@localhost.com")
	insert(:user, nickname: "localhost@localhost.com")

	[result] = User.search("lain@localhost", resolve: true, for_user: user)
	assert Map.put(result, :search_rank, nil) \|> Map.put(:search_type, nil) == local_user
	end

	test "works with idna domains" do
	user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))

	results = User.search("lain@zetsubou.みんな", resolve: false, for_user: user)

	result = List.first(results)

	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end

	test "works with idna domains converted input" do
	user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))

	results =
	User.search("lain@zetsubou." <> to_string(:idna.encode("zetsubou.みんな")),
	resolve: false,
	for_user: user
	)

	result = List.first(results)

	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end

	test "works with idna domains and bad chars in domain" do
	user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))

	results =
	User.search("lain@zetsubou!@#$%^&*()+,-/:;<=>?[]'_{}\|~`.みんな",
	resolve: false,
	for_user: user
	)

	result = List.first(results)

	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end

	test "works with idna domains and query as link" do
	user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))

	results =
	User.search("https://zetsubou.みんな/users/lain",
	resolve: false,
	for_user: user
	)

	result = List.first(results)

	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index 7bdad3810..804305a13 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,2180 +1,2260 @@
	# 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.ActivityPubTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Mock
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :federating])

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

	assert called(Pleroma.Web.Streamer.stream("participation", participations))
	end
	end

	test "streams them out on activity creation" do
	user_one = insert(:user)
	user_two = insert(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	{:ok, activity} =
	CommonAPI.post(user_one, %{
	status: "@#{user_two.nickname}",
	visibility: "direct"
	})

	conversation =
	activity.data["context"]
	\|> Pleroma.Conversation.get_for_ap_id()
	\|> Repo.preload(participations: :user)

	assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
	end
	end
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities = ActivityPub.fetch_activities([], %{visibility: "direct", actor_id: user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "unlisted", actor_id: user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "private", actor_id: user.ap_id})

	assert activities == [private_activity]

	activities = ActivityPub.fetch_activities([], %{visibility: "public", actor_id: user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	visibility: ~w[private public],
	actor_id: user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "fetching excluded by visibility" do
	test "it excludes by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "direct",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	refute direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "unlisted",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	refute unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "private",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	refute private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "public",
	actor_id: user.ap_id
	})

	refute public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.ap_enabled
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it returns a user that is invisible" do
	user_id = "http://mastodon.example.org/users/relay"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert User.invisible?(user)
	end

	test "it returns a user that accepts chat messages" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.accepts_chat_messages
	end
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{status: ". #test"})
	{:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{status: ". #test #reject"})

	fetch_one = ActivityPub.fetch_activities([], %{type: "Create", tag: "test"})

	fetch_two = ActivityPub.fetch_activities([], %{type: "Create", tag: ["test", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test", "essais"],
	tag_reject: ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test"],
	tag_all: ["test", "reject"]
	})

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, :remote_limit} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	assert activity.data["context_id"]
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	assert activity.data["context_id"]
	assert object.data["context_id"]
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert object = Object.normalize(activity)
	assert is_binary(object.data["id"])
	end
	end

	describe "listen activities" do
	test "does not increase user note count" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.listen(%{
	to: ["https://www.w3.org/ns/activitystreams#Public"],
	actor: user,
	context: "",
	object: %{
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"artist" => "lain",
	"title" => "lain radio episode 1",
	"length" => 180_000,
	"type" => "Audio"
	}
	})

	assert activity.actor == user.ap_id

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 0
	end

	test "can be fetched into a timeline" do
	_listen_activity_1 = insert(:listen)
	_listen_activity_2 = insert(:listen)
	_listen_activity_3 = insert(:listen)

	timeline = ActivityPub.fetch_activities([], %{type: ["Listen"]})

	assert length(timeline) == 3
	end
	end

	describe "create activities" do
	setup do
	[user: insert(:user)]
	end

	test "it reverts create", %{user: user} do
	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "creates activity if expiration is not configured and expires_at is not passed", %{
	user: user
	} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:ok, _} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	test "rejects activity if expires_at present but expiration is not configured", %{user: user} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:error, :expired_activities_disabled} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	},
	additional: %{
	"expires_at" => DateTime.utc_now()
	}
	})

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "removes doubled 'to' recipients", %{user: user} do
	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities", %{user: user} do
	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "1",
	visibility: "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "3",
	visibility: "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 2
	end

	test "increases replies count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	reply_data = %{status: "1", in_reply_to_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{blocking_user: user})
	assert activities == [activity_two, activity]
	end

	test "doesn't return activities with filtered words" do
	user = insert(:user)
	user_two = insert(:user)
	insert(:filter, user: user, phrase: "test", hide: true)

	{:ok, %{id: id1, data: %{"context" => context}}} = CommonAPI.post(user, %{status: "1"})

	{:ok, %{id: id2}} = CommonAPI.post(user_two, %{status: "2", in_reply_to_status_id: id1})

	{:ok, %{id: id3} = user_activity} =
	CommonAPI.post(user, %{status: "3 test?", in_reply_to_status_id: id2})

	{:ok, %{id: id4} = filtered_activity} =
	CommonAPI.post(user_two, %{status: "4 test!", in_reply_to_status_id: id3})

	{:ok, _} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	activities =
	context
	\|> ActivityPub.fetch_activities_for_context(%{user: user})
	\|> Enum.map(& &1.id)

	assert length(activities) == 4
	assert user_activity.id in activities
	refute filtered_activity.id in activities
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{blocking_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities with blocked users in 'to'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_three} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return announce activities with blocked users in 'cc'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert object = Pleroma.Object.normalize(activity_two)

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

	assert {:ok, activity_three} = ActivityPub.insert(data)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute activity in activities

	followed_user = insert(:user)
	CommonAPI.follow(user, followed_user)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, followed_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute repeat_activity in activities
	end

	test "does return activities from followed users on blocked domains" do
	domain = "meanies.social"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	blocker = insert(:user)

	{:ok, blocker} = User.follow(blocker, domain_user)
	{:ok, blocker} = User.block_domain(blocker, domain)

	assert User.following?(blocker, domain_user)
	assert User.blocks_domain?(blocker, domain_user)
	refute User.blocks?(blocker, domain_user)

	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	assert activity in activities

	# And check that if the guy we DO follow boosts someone else from their domain,
	# that should be hidden
	another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
	bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
	bad_activity = insert(:note_activity, %{note: bad_note})
	{:ok, repeat_activity} = CommonAPI.repeat(bad_activity.id, domain_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	refute repeat_activity in activities
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	muting_user: user,
	with_muted: true,
	skip_preload: true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_mute} = User.unmute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_three_actor)
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{muting_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return thread muted activities" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)

	assert [_activity_one] = ActivityPub.fetch_activities([], %{muting_user: user})
	end

	test "returns thread muted activities when with_muted is set" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)

	assert [_activity_two, _activity_one] =
	ActivityPub.fetch_activities([], %{muting_user: user, with_muted: true})
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	{:ok, user} = User.follow(user, booster)

	{:ok, announce} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| User.following(user)])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{exclude_reblogs: true})

	assert activity == expected_activity
	end

	describe "irreversible filters" do
	setup do
	user = insert(:user)
	user_two = insert(:user)

	insert(:filter, user: user_two, phrase: "cofe", hide: true)
	insert(:filter, user: user_two, phrase: "ok boomer", hide: true)
	insert(:filter, user: user_two, phrase: "test", hide: false)

	params = %{
	type: ["Create", "Announce"],
	user: user_two
	}

	{:ok, %{user: user, user_two: user_two, params: params}}
	end

	test "it returns statuses if they don't contain exact filter words", %{
	user: user,
	params: params
	} do
	{:ok, _} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _} = CommonAPI.post(user, %{status: "got cofefe?"})
	{:ok, _} = CommonAPI.post(user, %{status: "I am not a boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomers"})
	{:ok, _} = CommonAPI.post(user, %{status: "ccofee is not a word"})
	{:ok, _} = CommonAPI.post(user, %{status: "this is a test"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 6
	end

	test "it does not filter user's own statuses", %{user_two: user_two, params: params} do
	{:ok, _} = CommonAPI.post(user_two, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user_two, %{status: "ok boomer"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 2
	end

	test "it excludes statuses with filter words", %{user: user, params: params} do
	{:ok, _} = CommonAPI.post(user, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "is it a cOfE?"})
	{:ok, _} = CommonAPI.post(user, %{status: "cofe is all I need"})
	{:ok, _} = CommonAPI.post(user, %{status: "— ok BOOMER\n"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.empty?(activities)
	end

	test "it returns all statuses if user does not have any filters" do
	another_user = insert(:user)
	{:ok, _} = CommonAPI.post(another_user, %{status: "got cofe?"})
	{:ok, _} = CommonAPI.post(another_user, %{status: "test!"})

	activities =
	ActivityPub.fetch_activities([], %{
	type: ["Create", "Announce"],
	user: another_user
	})

	assert Enum.count(activities) == 2
	end
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	activities = ActivityPub.fetch_public_activities()

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 20
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	expected_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id

	activities = ActivityPub.fetch_public_activities(%{since_id: since_id})

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 10
	end

	test "retrieves ids up to max_id" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	%{id: max_id} =
	10
	\|> ActivityBuilder.insert_list()
	\|> List.first()

	activities = ActivityPub.fetch_public_activities(%{max_id: max_id})

	assert length(activities) == 20
	assert collect_ids(activities) == collect_ids(expected_activities)
	end

	test "paginates via offset/limit" do
	_first_part_activities = ActivityBuilder.insert_list(10)
	second_part_activities = ActivityBuilder.insert_list(10)

	later_activities = ActivityBuilder.insert_list(10)

	activities = ActivityPub.fetch_public_activities(%{page: "2", page_size: "20"}, :offset)

	assert length(activities) == 20

	assert collect_ids(activities) ==
	collect_ids(second_part_activities) ++ collect_ids(later_activities)
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(user, booster)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "uploading files" do
	setup do
	test_file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	%{test_file: test_file}
	end

	test "sets a description if given", %{test_file: file} do
	{:ok, %Object{} = object} = ActivityPub.upload(file, description: "a cool file")
	assert object.data["name"] == "a cool file"
	end

	test "it sets the default description depending on the configuration", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description])

	Pleroma.Config.put([Pleroma.Upload, :default_description], nil)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == ""

	Pleroma.Config.put([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"

	Pleroma.Config.put([Pleroma.Upload, :default_description], "unnamed attachment")
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "unnamed attachment"
	end

	test "copies the file to the configured folder", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	img: data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = Repo.get_by(User, ap_id: activity.data["actor"])
	followed = Repo.get_by(User, ap_id: activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "unfollowing" do
	test "it reverts unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
	end

	activity = Activity.get_by_id(follow_activity.id)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id

	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "creates an undo activity for a pending follow request" do
	follower = insert(:user)
	followed = insert(:user, %{locked: true})

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})

	{:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	status: "hi 3",
	visibility: "private",
	in_reply_to_status_id: private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	status: "hi 4",
	visibility: "private",
	in_reply_to_status_id: private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)], %{user: user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "flag/1" do
	setup do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]

	activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)

	{:ok,
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: activity,
	content: content,
	activity_ap_id: activity_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	}}
	end

	test "it can create a Flag activity",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content,
	activity_ap_id: activity_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	} do
	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	note_obj = %{
	"type" => "Note",
	"id" => activity_ap_id,
	"content" => content,
	"published" => activity_with_object.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj]
	}
	} = activity
	end

	test_with_mock "strips status data from Flag, before federating it",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	[] do
	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	new_data =
	put_in(activity.data, ["object"], [target_account.ap_id, reported_activity.data["id"]])

	assert_called(Utils.maybe_federate(%{activity \| data: new_data}))
	end
	end

	test "fetch_activities/2 returns activities addressed to a list " do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	{:ok, list} = Pleroma.List.follow(list, member)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	activity = Repo.preload(activity, :bookmark)
	activity = %Activity{activity \| thread_muted?: !!activity.thread_muted?}

	assert ActivityPub.fetch_activities([], %{user: user}) == [activity]
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end

	describe "fetch_activities_bounded" do
	test "fetches private posts for followed users" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "thought I looked cute might delete later :3",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
	assert result.id == activity.id
	end

	test "fetches only public posts for other users" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})

	{:ok, _private_activity} =
	CommonAPI.post(user, %{
	status: "why is tenshi eating a corndog so cute?",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
	assert result.id == activity.id
	end
	end

	describe "fetch_follow_information_for_user" do
	test "syncronizes following/followers counters" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	)

	{:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
	assert info.follower_count == 527
	assert info.following_count == 267
	end

	test "detects hidden followers" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.hide_follows == false
	end

	test "detects hidden follows" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == false
	assert follow_info.hide_follows == true
	end

	test "detects hidden follows/followers for friendica" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:8080/followers/fuser3",
	following_address: "http://localhost:8080/following/fuser3"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 296
	assert follow_info.following_count == 32
	assert follow_info.hide_follows == true
	end

	test "doesn't crash when follower and following counters are hidden" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_hidden_counters/following" ->
	json(%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/followers"
	})

	"http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	"http://localhost:4001/users/masto_hidden_counters/followers" ->
	json(%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/following"
	})

	"http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
	following_address: "http://localhost:4001/users/masto_hidden_counters/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)

	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 0
	assert follow_info.hide_follows == true
	assert follow_info.following_count == 0
	end
	end

	describe "fetch_favourites/3" do
	test "returns a favourite activities sorted by adds to favorite" do
	user = insert(:user)
	other_user = insert(:user)
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
	{:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
	{:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
	{:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
	{:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})

	{:ok, _} = CommonAPI.favorite(user, a4.id)
	{:ok, _} = CommonAPI.favorite(other_user, a3.id)
	{:ok, _} = CommonAPI.favorite(user, a3.id)
	{:ok, _} = CommonAPI.favorite(other_user, a5.id)
	{:ok, _} = CommonAPI.favorite(user, a5.id)
	{:ok, _} = CommonAPI.favorite(other_user, a4.id)
	{:ok, _} = CommonAPI.favorite(user, a1.id)
	{:ok, _} = CommonAPI.favorite(other_user, a1.id)
	result = ActivityPub.fetch_favourites(user)

	assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]

	result = ActivityPub.fetch_favourites(user, %{limit: 2})
	assert Enum.map(result, & &1.id) == [a1.id, a5.id]
	end
	end

	describe "Move activity" do
	test "create" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	follower_move_opted_out = insert(:user, allow_following_move: false)

	User.follow(follower, old_user)
	User.follow(follower_move_opted_out, old_user)

	assert User.following?(follower, old_user)
	assert User.following?(follower_move_opted_out, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true
	} = activity

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, old_user)
	assert User.following?(follower, new_user)

	assert User.following?(follower_move_opted_out, old_user)
	refute User.following?(follower_move_opted_out, new_user)

	activity = %Activity{activity \| object: nil}

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower)

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
	end

	test "old user must be in the new user's `also_known_as` list" do
	old_user = insert(:user)
	new_user = insert(:user)

	assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
	ActivityPub.move(old_user, new_user)
	end
	end

	test "doesn't retrieve replies activities with exclude_replies" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})

	{:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})

	[result] = ActivityPub.fetch_public_activities(%{exclude_replies: true})

	assert result.id == activity.id

	assert length(ActivityPub.fetch_public_activities()) == 2
	end

	describe "replies filtering with public messages" do
	setup :public_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 16
	end

	test "public timeline with reply_visibility `following`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 14

	visible_ids =
	Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "public timeline with reply_visibility `self`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10
	visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 13

	visible_ids =
	Map.values(u1) ++
	Map.values(u3) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `following`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 11

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u3[:r1],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 9

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u3[:r1],
	u4[:r1]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "filtering out announces where the user is the actor of the announced message" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	User.follow(user, other_user)

	{:ok, post} = CommonAPI.post(user, %{status: "yo"})
	{:ok, other_post} = CommonAPI.post(third_user, %{status: "yo"})
	{:ok, _announce} = CommonAPI.repeat(post.id, other_user)
	{:ok, _announce} = CommonAPI.repeat(post.id, third_user)
	{:ok, announce} = CommonAPI.repeat(other_post.id, other_user)

	params = %{
	type: ["Announce"]
	}

	results =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert length(results) == 3

	params = %{
	type: ["Announce"],
	announce_filtering_user: user
	}

	[result] =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert result.id == announce.id
	end
	end

	describe "replies filtering with private messages" do
	setup :private_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []

	activities_ids =
	%{}
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, nil)
	\|> ActivityPub.fetch_public_activities()

	assert activities_ids == []
	end

	test "home timeline", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10

	visible_ids =
	Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end
	end

	defp public_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1} = User.follow(u1, u2)
	{:ok, u2} = User.follow(u2, u1)
	{:ok, u1} = User.follow(u1, u4)
	{:ok, u4} = User.follow(u4, u1)

	{:ok, u2} = User.follow(u2, u3)
	{:ok, u3} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_3} =
	CommonAPI.post(u4, %{
	status: "@#{u2.nickname} reply from u4 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_3} =
	CommonAPI.post(u4, %{
	status: "@#{u3.nickname} reply from u4 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_2} =
	CommonAPI.post(u2, %{
	status: "@#{u4.nickname} reply from u2 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_3} =
	CommonAPI.post(u3, %{
	status: "@#{u4.nickname} reply from u3 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
	u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
	u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
	end

	defp private_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1} = User.follow(u1, u2)
	{:ok, u2} = User.follow(u2, u1)
	{:ok, u1} = User.follow(u1, u3)
	{:ok, u3} = User.follow(u3, u1)
	{:ok, u1} = User.follow(u1, u4)
	{:ok, u4} = User.follow(u4, u1)

	{:ok, u2} = User.follow(u2, u3)
	{:ok, u3} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id,
	visibility: "private"
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id},
	u3: %{r1: r3_1.id, r2: r3_2.id},
	u4: %{r1: r4_1.id}}
	end

	describe "maybe_update_follow_information/1" do
	setup do
	clear_config([:instance, :external_user_synchronization], true)

	user = %{
	local: false,
	ap_id: "https://gensokyo.2hu/users/raymoo",
	following_address: "https://gensokyo.2hu/users/following",
	follower_address: "https://gensokyo.2hu/users/followers",
	type: "Person"
	}

	%{user: user}
	end

	test "logs an error when it can't fetch the info", %{user: user} do
	assert capture_log(fn ->
	ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "just returns the input if the user type is Application", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:type, "Application")

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "it just returns the input if the user has no following/follower addresses", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:following_address, nil)
	\|> Map.put(:follower_address, nil)

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end
	end

	describe "global activity expiration" do
	test "creates an activity expiration for local Create activities" do
	clear_config([:mrf, :policies], Pleroma.Web.ActivityPub.MRF.ActivityExpirationPolicy)

	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, follow} = ActivityBuilder.insert(%{"type" => "Follow", "context" => "3hu"})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at:
	activity.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	refute_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: follow.id}
	)
	end
	end

	describe "handling of clashing nicknames" do
	test "renames an existing user with a clashing nickname and a different ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id <> "part_2"
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
	end

	test "does nothing with a clashing nickname and the same ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == orig_user.nickname
	end
	end
	+
	+ describe "reply filtering" do
	+ test "`following` still contains announcements by friends" do
	+ user = insert(:user)
	+ followed = insert(:user)
	+ not_followed = insert(:user)
	+
	+ User.follow(user, followed)
	+
	+ {:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})
	+
	+ {:ok, not_followed_to_followed} =
	+ CommonAPI.post(not_followed, %{
	+ status: "Also hello",
	+ in_reply_to_status_id: followed_post.id
	+ })
	+
	+ {:ok, retoot} = CommonAPI.repeat(not_followed_to_followed.id, followed)
	+
	+ params =
	+ %{}
	+ \|> Map.put(:type, ["Create", "Announce"])
	+ \|> Map.put(:blocking_user, user)
	+ \|> Map.put(:muting_user, user)
	+ \|> Map.put(:reply_filtering_user, user)
	+ \|> Map.put(:reply_visibility, "following")
	+ \|> Map.put(:announce_filtering_user, user)
	+ \|> Map.put(:user, user)
	+
	+ activities =
	+ [user.ap_id \| User.following(user)]
	+ \|> ActivityPub.fetch_activities(params)
	+
	+ followed_post_id = followed_post.id
	+ retoot_id = retoot.id
	+
	+ assert [%{id: ^followed_post_id}, %{id: ^retoot_id}] = activities
	+
	+ assert length(activities) == 2
	+ end
	+
	+ # This test is skipped because, while this is the desired behavior,
	+ # there seems to be no good way to achieve it with the method that
	+ # we currently use for detecting to who a reply is directed.
	+ # This is a TODO and should be fixed by a later rewrite of the code
	+ # in question.
	+ @tag skip: true
	+ test "`following` still contains self-replies by friends" do
	+ user = insert(:user)
	+ followed = insert(:user)
	+ not_followed = insert(:user)
	+
	+ User.follow(user, followed)
	+
	+ {:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})
	+ {:ok, not_followed_post} = CommonAPI.post(not_followed, %{status: "Also hello"})
	+
	+ {:ok, _followed_to_not_followed} =
	+ CommonAPI.post(followed, %{status: "sup", in_reply_to_status_id: not_followed_post.id})
	+
	+ {:ok, _followed_self_reply} =
	+ CommonAPI.post(followed, %{status: "Also cofe", in_reply_to_status_id: followed_post.id})
	+
	+ params =
	+ %{}
	+ \|> Map.put(:type, ["Create", "Announce"])
	+ \|> Map.put(:blocking_user, user)
	+ \|> Map.put(:muting_user, user)
	+ \|> Map.put(:reply_filtering_user, user)
	+ \|> Map.put(:reply_visibility, "following")
	+ \|> Map.put(:announce_filtering_user, user)
	+ \|> Map.put(:user, user)
	+
	+ activities =
	+ [user.ap_id \| User.following(user)]
	+ \|> ActivityPub.fetch_activities(params)
	+
	+ assert length(activities) == 2
	+ end
	+ end
	end
	diff --git a/test/web/activity_pub/relay_test.exs b/test/web/activity_pub/relay_test.exs
	index 9d657ac4f..3284980f7 100644
	--- a/test/web/activity_pub/relay_test.exs
	+++ b/test/web/activity_pub/relay_test.exs
	@@ -1,128 +1,168 @@
	# 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.RelayTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Mock

	test "gets an actor for the relay" do
	user = Relay.get_actor()
	assert user.ap_id == "#{Pleroma.Web.Endpoint.url()}/relay"
	end

	test "relay actor is invisible" do
	user = Relay.get_actor()
	assert User.invisible?(user)
	end

	describe "follow/1" do
	test "returns errors when user not found" do
	assert capture_log(fn ->
	{:error, _} = Relay.follow("test-ap-id")
	end) =~ "Could not decode user at fetch"
	end

	test "returns activity" do
	user = insert(:user)
	service_actor = Relay.get_actor()
	assert {:ok, %Activity{} = activity} = Relay.follow(user.ap_id)
	assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	assert user.ap_id in activity.recipients
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["object"] == user.ap_id
	end
	end

	describe "unfollow/1" do
	test "returns errors when user not found" do
	assert capture_log(fn ->
	{:error, _} = Relay.unfollow("test-ap-id")
	end) =~ "Could not decode user at fetch"
	end

	test "returns activity" do
	user = insert(:user)
	service_actor = Relay.get_actor()
	CommonAPI.follow(service_actor, user)
	assert "#{user.ap_id}/followers" in User.following(service_actor)
	assert {:ok, %Activity{} = activity} = Relay.unfollow(user.ap_id)
	assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	assert user.ap_id in activity.recipients
	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["to"] == [user.ap_id]
	refute "#{user.ap_id}/followers" in User.following(service_actor)
	end
	+
	+ test "force unfollow when target service is dead" do
	+ user = insert(:user)
	+ user_ap_id = user.ap_id
	+ user_id = user.id
	+
	+ Tesla.Mock.mock(fn %{method: :get, url: ^user_ap_id} ->
	+ %Tesla.Env{status: 404}
	+ end)
	+
	+ service_actor = Relay.get_actor()
	+ CommonAPI.follow(service_actor, user)
	+ assert "#{user.ap_id}/followers" in User.following(service_actor)
	+
	+ assert Pleroma.Repo.get_by(
	+ Pleroma.FollowingRelationship,
	+ follower_id: service_actor.id,
	+ following_id: user_id
	+ )
	+
	+ Pleroma.Repo.delete(user)
	+ Cachex.clear(:user_cache)
	+
	+ assert {:ok, %Activity{} = activity} = Relay.unfollow(user_ap_id, %{force: true})
	+
	+ assert refresh_record(service_actor).following_count == 0
	+
	+ refute Pleroma.Repo.get_by(
	+ Pleroma.FollowingRelationship,
	+ follower_id: service_actor.id,
	+ following_id: user_id
	+ )
	+
	+ assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	+ assert user.ap_id in activity.recipients
	+ assert activity.data["type"] == "Undo"
	+ assert activity.data["actor"] == service_actor.ap_id
	+ assert activity.data["to"] == [user_ap_id]
	+ refute "#{user.ap_id}/followers" in User.following(service_actor)
	+ end
	end

	describe "publish/1" do
	setup do: clear_config([:instance, :federating])

	test "returns error when activity not `Create` type" do
	activity = insert(:like_activity)
	assert Relay.publish(activity) == {:error, "Not implemented"}
	end

	@tag capture_log: true
	test "returns error when activity not public" do
	activity = insert(:direct_note_activity)
	assert Relay.publish(activity) == {:error, false}
	end

	test "returns error when object is unknown" do
	activity =
	insert(:note_activity,
	data: %{
	"type" => "Create",
	"object" => "http://mastodon.example.org/eee/99541947525187367"
	}
	)

	Tesla.Mock.mock(fn
	%{method: :get, url: "http://mastodon.example.org/eee/99541947525187367"} ->
	%Tesla.Env{status: 500, body: ""}
	end)

	assert capture_log(fn ->
	assert Relay.publish(activity) == {:error, false}
	end) =~ "[error] error: false"
	end

	test_with_mock "returns announce activity and publish to federate",
	Pleroma.Web.Federator,
	[:passthrough],
	[] do
	clear_config([:instance, :federating], true)
	service_actor = Relay.get_actor()
	note = insert(:note_activity)
	assert {:ok, %Activity{} = activity} = Relay.publish(note)
	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == service_actor.ap_id
	assert activity.data["to"] == [service_actor.follower_address]
	assert called(Pleroma.Web.Federator.publish(activity))
	end

	test_with_mock "returns announce activity and not publish to federate",
	Pleroma.Web.Federator,
	[:passthrough],
	[] do
	clear_config([:instance, :federating], false)
	service_actor = Relay.get_actor()
	note = insert(:note_activity)
	assert {:ok, %Activity{} = activity} = Relay.publish(note)
	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == service_actor.ap_id
	refute called(Pleroma.Web.Federator.publish(activity))
	end
	end
	end
	diff --git a/test/web/media_proxy/media_proxy_controller_test.exs b/test/web/media_proxy/media_proxy_controller_test.exs
	index 33e6873f7..e9b584822 100644
	--- a/test/web/media_proxy/media_proxy_controller_test.exs
	+++ b/test/web/media_proxy/media_proxy_controller_test.exs
	@@ -1,327 +1,342 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MediaProxy.MediaProxyControllerTest do
	use Pleroma.Web.ConnCase

	import Mock

	alias Pleroma.Web.MediaProxy
	alias Plug.Conn

	setup do
	on_exit(fn -> Cachex.clear(:banned_urls_cache) end)
	end

	describe "Media Proxy" do
	setup do
	clear_config([:media_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")

	[url: MediaProxy.encode_url("https://google.fn/test.png")]
	end

	test "it returns 404 when disabled", %{conn: conn} do
	clear_config([:media_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/hhgfh/eeee/fff")
	end

	test "it returns 403 for invalid signature", %{conn: conn, url: url} do
	Pleroma.Config.put([Pleroma.Web.Endpoint, :secret_key_base], "000")
	%{path: path} = URI.parse(url)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, path)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/hhgfh/eeee")

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/hhgfh/eeee/fff")
	end

	test "redirects to valid url when filename is invalidated", %{conn: conn, url: url} do
	invalid_url = String.replace(url, "test.png", "test-file.png")
	response = get(conn, invalid_url)
	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "it performs ReverseProxy.call with valid signature", %{conn: conn, url: url} do
	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Conn{status: :success} end do
	assert %Conn{status: :success} = get(conn, url)
	end
	end

	test "it returns 404 when url is in banned_urls cache", %{conn: conn, url: url} do
	MediaProxy.put_in_banned_urls("https://google.fn/test.png")

	with_mock Pleroma.ReverseProxy,
	call: fn _conn, _url, _opts -> %Conn{status: :success} end do
	assert %Conn{status: 404, resp_body: "Not Found"} = get(conn, url)
	end
	end
	end

	describe "Media Preview Proxy" do
	+ def assert_dependencies_installed do
	+ missing_dependencies = Pleroma.Helpers.MediaHelper.missing_dependencies()
	+
	+ assert missing_dependencies == [],
	+ "Error: missing dependencies (please refer to `docs/installation`): #{
	+ inspect(missing_dependencies)
	+ }"
	+ end
	+
	setup do
	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_preview_proxy, :enabled], true)
	clear_config([Pleroma.Web.Endpoint, :secret_key_base], "00000000000")

	original_url = "https://google.fn/test.png"

	[
	url: MediaProxy.encode_preview_url(original_url),
	media_proxy_url: MediaProxy.encode_url(original_url)
	]
	end

	test "returns 404 when media proxy is disabled", %{conn: conn} do
	clear_config([:media_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/fff")
	end

	test "returns 404 when disabled", %{conn: conn} do
	clear_config([:media_preview_proxy, :enabled], false)

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/eeeee")

	assert %Conn{
	status: 404,
	resp_body: "Not Found"
	} = get(conn, "/proxy/preview/hhgfh/fff")
	end

	test "it returns 403 for invalid signature", %{conn: conn, url: url} do
	Pleroma.Config.put([Pleroma.Web.Endpoint, :secret_key_base], "000")
	%{path: path} = URI.parse(url)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, path)

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/preview/hhgfh/eeee")

	assert %Conn{
	status: 403,
	resp_body: "Forbidden"
	} = get(conn, "/proxy/preview/hhgfh/eeee/fff")
	end

	test "redirects to valid url when filename is invalidated", %{conn: conn, url: url} do
	invalid_url = String.replace(url, "test.png", "test-file.png")
	response = get(conn, invalid_url)
	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "responds with 424 Failed Dependency if HEAD request to media proxy fails", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 500, body: ""}
	end)

	response = get(conn, url)
	assert response.status == 424
	assert response.resp_body == "Can't fetch HTTP headers (HTTP 500)."
	end

	test "redirects to media proxy URI on unsupported content type", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "application/pdf"}]}
	end)

	response = get(conn, url)
	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "with `static=true` and GIF image preview requested, responds with JPEG image", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	+ assert_dependencies_installed()
	+
	# Setting a high :min_content_length to ensure this scenario is not affected by its logic
	clear_config([:media_preview_proxy, :min_content_length], 1_000_000_000)

	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{
	status: 200,
	body: "",
	headers: [{"content-type", "image/gif"}, {"content-length", "1001718"}]
	}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.gif")}
	end)

	response = get(conn, url <> "?static=true")

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/jpeg"]
	assert response.resp_body != ""
	end

	test "with GIF image preview requested and no `static` param, redirects to media proxy URI",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/gif"}]}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "with `static` param and non-GIF image preview requested, " <>
	"redirects to media preview proxy URI without `static` param",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}
	end)

	response = get(conn, url <> "?static=true")

	assert response.status == 302
	assert redirected_to(response) == url
	end

	test "with :min_content_length setting not matched by Content-Length header, " <>
	"redirects to media proxy URI",
	%{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	clear_config([:media_preview_proxy, :min_content_length], 100_000)

	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{
	status: 200,
	body: "",
	headers: [{"content-type", "image/gif"}, {"content-length", "5000"}]
	}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end

	test "thumbnails PNG images into PNG", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	+ assert_dependencies_installed()
	+
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/png"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.png")}
	end)

	response = get(conn, url)

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/png"]
	assert response.resp_body != ""
	end

	test "thumbnails JPEG images into JPEG", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	+ assert_dependencies_installed()
	+
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/image.jpg")}
	end)

	response = get(conn, url)

	assert response.status == 200
	assert Conn.get_resp_header(response, "content-type") == ["image/jpeg"]
	assert response.resp_body != ""
	end

	test "redirects to media proxy URI in case of thumbnailing error", %{
	conn: conn,
	url: url,
	media_proxy_url: media_proxy_url
	} do
	Tesla.Mock.mock(fn
	%{method: "head", url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "", headers: [{"content-type", "image/jpeg"}]}

	%{method: :get, url: ^media_proxy_url} ->
	%Tesla.Env{status: 200, body: "<html><body>error</body></html>"}
	end)

	response = get(conn, url)

	assert response.status == 302
	assert redirected_to(response) == media_proxy_url
	end
	end
	end
	diff --git a/test/web/pleroma_api/controllers/emoji_file_controller_test.exs b/test/web/pleroma_api/controllers/emoji_file_controller_test.exs
	index 39b4e1dac..82de86ee3 100644
	--- a/test/web/pleroma_api/controllers/emoji_file_controller_test.exs
	+++ b/test/web/pleroma_api/controllers/emoji_file_controller_test.exs
	@@ -1,357 +1,357 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.EmojiFileControllerTest do
	use Pleroma.Web.ConnCase

	import Tesla.Mock
	import Pleroma.Factory

	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)
	setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)

	setup do: clear_config([:instance, :public], true)

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

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

	Pleroma.Emoji.reload()
	{:ok, %{admin_conn: admin_conn}}
	end

	- describe "POST/PATCH/DELETE /api/pleroma/emoji/packs/:name/files" do
	+ describe "POST/PATCH/DELETE /api/pleroma/emoji/packs/files?name=:name" do
	setup do
	pack_file = "#{@emoji_path}/test_pack/pack.json"
	original_content = File.read!(pack_file)

	on_exit(fn ->
	File.write!(pack_file, original_content)
	end)

	:ok
	end

	test "upload zip file with emojies", %{admin_conn: admin_conn} do
	on_exit(fn ->
	[
	"128px/a_trusted_friend-128.png",
	"auroraborealis.png",
	"1000px/baby_in_a_box.png",
	"1000px/bear.png",
	"128px/bear-128.png"
	]
	\|> Enum.each(fn path -> File.rm_rf!("#{@emoji_path}/test_pack/#{path}") end)
	end)

	resp =
	admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
	file: %Plug.Upload{
	content_type: "application/zip",
	filename: "emojis.zip",
	path: Path.absname("test/fixtures/emojis.zip")
	}
	})
	\|> json_response_and_validate_schema(200)

	assert resp == %{
	"a_trusted_friend-128" => "128px/a_trusted_friend-128.png",
	"auroraborealis" => "auroraborealis.png",
	"baby_in_a_box" => "1000px/baby_in_a_box.png",
	"bear" => "1000px/bear.png",
	"bear-128" => "128px/bear-128.png",
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}

	Enum.each(Map.values(resp), fn path ->
	assert File.exists?("#{@emoji_path}/test_pack/#{path}")
	end)
	end

	test "create shortcode exists", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(:conflict) == %{
	"error" => "An emoji with the \"blank\" shortcode already exists"
	}
	end

	test "don't rewrite old emoji", %{admin_conn: admin_conn} do
	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir/") end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank3",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank2" => "blank2.png",
	"blank3" => "dir/blank.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank",
	new_shortcode: "blank2",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(:conflict) == %{
	"error" =>
	"New shortcode \"blank2\" is already used. If you want to override emoji use 'force' option"
	}
	end

	test "rewrite old emoji with force option", %{admin_conn: admin_conn} do
	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir_2/") end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank3",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank2" => "blank2.png",
	"blank3" => "dir/blank.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank3",
	new_shortcode: "blank4",
	new_filename: "dir_2/blank_3.png",
	force: true
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank2" => "blank2.png",
	"blank4" => "dir_2/blank_3.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")
	end

	test "with empty filename", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank2",
	filename: "",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(422) == %{
	"error" => "pack name, shortcode or filename cannot be empty"
	}
	end

	test "add file with not loaded pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/not_loaded/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=not_loaded", %{
	shortcode: "blank3",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "pack \"not_loaded\" is not found"
	}
	end

	test "remove file with not loaded pack", %{admin_conn: admin_conn} do
	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=blank3")
	+ \|> delete("/api/pleroma/emoji/packs/files?name=not_loaded&shortcode=blank3")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "pack \"not_loaded\" is not found"
	}
	end

	test "remove file with empty shortcode", %{admin_conn: admin_conn} do
	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/not_loaded/files?shortcode=")
	+ \|> delete("/api/pleroma/emoji/packs/files?name=not_loaded&shortcode=")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "pack \"not_loaded\" is not found"
	}
	end

	test "update file with not loaded pack", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/not_loaded/files", %{
	+ \|> patch("/api/pleroma/emoji/packs/files?name=not_loaded", %{
	shortcode: "blank4",
	new_shortcode: "blank3",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "pack \"not_loaded\" is not found"
	}
	end

	test "new with shortcode as file with update", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank4",
	filename: "dir/blank.png",
	file: %Plug.Upload{
	filename: "blank.png",
	path: "#{@emoji_path}/test_pack/blank.png"
	}
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank4" => "dir/blank.png",
	"blank2" => "blank2.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/dir/blank.png")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank4",
	new_shortcode: "blank3",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank3" => "dir_2/blank_3.png",
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}

	refute File.exists?("#{@emoji_path}/test_pack/dir/")
	assert File.exists?("#{@emoji_path}/test_pack/dir_2/blank_3.png")

	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
	+ \|> delete("/api/pleroma/emoji/packs/files?name=test_pack&shortcode=blank3")
	\|> json_response_and_validate_schema(200) == %{
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}

	refute File.exists?("#{@emoji_path}/test_pack/dir_2/")

	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/dir") end)
	end

	test "new with shortcode from url", %{admin_conn: admin_conn} do
	mock(fn
	%{
	method: :get,
	url: "https://test-blank/blank_url.png"
	} ->
	text(File.read!("#{@emoji_path}/test_pack/blank.png"))
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank_url",
	file: "https://test-blank/blank_url.png"
	})
	\|> json_response_and_validate_schema(200) == %{
	"blank_url" => "blank_url.png",
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}

	assert File.exists?("#{@emoji_path}/test_pack/blank_url.png")

	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/blank_url.png") end)
	end

	test "new without shortcode", %{admin_conn: admin_conn} do
	on_exit(fn -> File.rm_rf!("#{@emoji_path}/test_pack/shortcode.png") end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> post("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> post("/api/pleroma/emoji/packs/files?name=test_pack", %{
	file: %Plug.Upload{
	filename: "shortcode.png",
	path: "#{Pleroma.Config.get([:instance, :static_dir])}/add/shortcode.png"
	}
	})
	\|> json_response_and_validate_schema(200) == %{
	"shortcode" => "shortcode.png",
	"blank" => "blank.png",
	"blank2" => "blank2.png"
	}
	end

	test "remove non existing shortcode in pack.json", %{admin_conn: admin_conn} do
	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/test_pack/files?shortcode=blank3")
	+ \|> delete("/api/pleroma/emoji/packs/files?name=test_pack&shortcode=blank3")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "Emoji \"blank3\" does not exist"
	}
	end

	test "update non existing emoji", %{admin_conn: admin_conn} do
	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank3",
	new_shortcode: "blank4",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "Emoji \"blank3\" does not exist"
	}
	end

	test "update with empty shortcode", %{admin_conn: admin_conn} do
	assert %{
	"error" => "Missing field: new_shortcode."
	} =
	admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack/files", %{
	+ \|> patch("/api/pleroma/emoji/packs/files?name=test_pack", %{
	shortcode: "blank",
	new_filename: "dir_2/blank_3.png"
	})
	\|> json_response_and_validate_schema(:bad_request)
	end
	end
	end
	diff --git a/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs b/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	index a34df2c18..386ad8634 100644
	--- a/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	+++ b/test/web/pleroma_api/controllers/emoji_pack_controller_test.exs
	@@ -1,574 +1,604 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.EmojiPackControllerTest do
	use Pleroma.Web.ConnCase

	import Tesla.Mock
	import Pleroma.Factory

	@emoji_path Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)
	setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)

	setup do: clear_config([:instance, :public], true)

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

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

	Pleroma.Emoji.reload()
	{:ok, %{admin_conn: admin_conn}}
	end

	test "GET /api/pleroma/emoji/packs when :public: false", %{conn: conn} do
	Config.put([:instance, :public], false)
	conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)
	end

	test "GET /api/pleroma/emoji/packs", %{conn: conn} do
	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	- assert resp["count"] == 3
	+ assert resp["count"] == 4

	assert resp["packs"]
	\|> Map.keys()
	- \|> length() == 3
	+ \|> length() == 4

	shared = resp["packs"]["test_pack"]
	assert shared["files"] == %{"blank" => "blank.png", "blank2" => "blank2.png"}
	assert Map.has_key?(shared["pack"], "download-sha256")
	assert shared["pack"]["can-download"]
	assert shared["pack"]["share-files"]

	non_shared = resp["packs"]["test_pack_nonshared"]
	assert non_shared["pack"]["share-files"] == false
	assert non_shared["pack"]["can-download"] == false

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1")
	\|> json_response_and_validate_schema(200)

	- assert resp["count"] == 3
	+ assert resp["count"] == 4

	packs = Map.keys(resp["packs"])

	assert length(packs) == 1

	[pack1] = packs

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1&page=2")
	\|> json_response_and_validate_schema(200)

	- assert resp["count"] == 3
	+ assert resp["count"] == 4
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack2] = packs

	resp =
	conn
	\|> get("/api/pleroma/emoji/packs?page_size=1&page=3")
	\|> json_response_and_validate_schema(200)

	- assert resp["count"] == 3
	+ assert resp["count"] == 4
	packs = Map.keys(resp["packs"])
	assert length(packs) == 1
	[pack3] = packs
	- assert [pack1, pack2, pack3] \|> Enum.uniq() \|> length() == 3
	+
	+ resp =
	+ conn
	+ \|> get("/api/pleroma/emoji/packs?page_size=1&page=4")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert resp["count"] == 4
	+ packs = Map.keys(resp["packs"])
	+ assert length(packs) == 1
	+ [pack4] = packs
	+ assert [pack1, pack2, pack3, pack4] \|> Enum.uniq() \|> length() == 4
	end

	describe "GET /api/pleroma/emoji/packs/remote" do
	test "shareable instance", %{admin_conn: admin_conn, conn: conn} do
	resp =
	conn
	- \|> get("/api/pleroma/emoji/packs")
	+ \|> get("/api/pleroma/emoji/packs?page=2&page_size=1")
	\|> json_response_and_validate_schema(200)

	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	- %{method: :get, url: "https://example.com/api/pleroma/emoji/packs"} ->
	+ %{method: :get, url: "https://example.com/api/pleroma/emoji/packs?page=2&page_size=1"} ->
	json(resp)
	end)

	assert admin_conn
	- \|> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
	+ \|> get("/api/pleroma/emoji/packs/remote?url=https://example.com&page=2&page_size=1")
	\|> json_response_and_validate_schema(200) == resp
	end

	test "non shareable instance", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: []}})
	end)

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/remote?url=https://example.com")
	\|> json_response_and_validate_schema(500) == %{
	"error" => "The requested instance does not support sharing emoji packs"
	}
	end
	end

	- describe "GET /api/pleroma/emoji/packs/:name/archive" do
	+ describe "GET /api/pleroma/emoji/packs/archive?name=:name" do
	test "download shared pack", %{conn: conn} do
	resp =
	conn
	- \|> get("/api/pleroma/emoji/packs/test_pack/archive")
	+ \|> get("/api/pleroma/emoji/packs/archive?name=test_pack")
	\|> response(200)

	{:ok, arch} = :zip.unzip(resp, [:memory])

	assert Enum.find(arch, fn {n, _} -> n == 'pack.json' end)
	assert Enum.find(arch, fn {n, _} -> n == 'blank.png' end)
	end

	test "non existing pack", %{conn: conn} do
	assert conn
	- \|> get("/api/pleroma/emoji/packs/test_pack_for_import/archive")
	+ \|> get("/api/pleroma/emoji/packs/archive?name=test_pack_for_import")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack test_pack_for_import does not exist"
	}
	end

	test "non downloadable pack", %{conn: conn} do
	assert conn
	- \|> get("/api/pleroma/emoji/packs/test_pack_nonshared/archive")
	+ \|> get("/api/pleroma/emoji/packs/archive?name=test_pack_nonshared")
	\|> json_response_and_validate_schema(:forbidden) == %{
	"error" =>
	"Pack test_pack_nonshared cannot be downloaded from this instance, either pack sharing was disabled for this pack or some files are missing"
	}
	end
	end

	describe "POST /api/pleroma/emoji/packs/download" do
	test "shared pack from remote and non shared from fallback-src", %{
	admin_conn: admin_conn,
	conn: conn
	} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	- url: "https://example.com/api/pleroma/emoji/packs/test_pack"
	+ url: "https://example.com/api/pleroma/emoji/pack?name=test_pack"
	} ->
	conn
	- \|> get("/api/pleroma/emoji/packs/test_pack")
	+ \|> get("/api/pleroma/emoji/pack?name=test_pack")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	- url: "https://example.com/api/pleroma/emoji/packs/test_pack/archive"
	+ url: "https://example.com/api/pleroma/emoji/packs/archive?name=test_pack"
	} ->
	conn
	- \|> get("/api/pleroma/emoji/packs/test_pack/archive")
	+ \|> get("/api/pleroma/emoji/packs/archive?name=test_pack")
	\|> response(200)
	\|> text()

	%{
	method: :get,
	- url: "https://example.com/api/pleroma/emoji/packs/test_pack_nonshared"
	+ url: "https://example.com/api/pleroma/emoji/pack?name=test_pack_nonshared"
	} ->
	conn
	- \|> get("/api/pleroma/emoji/packs/test_pack_nonshared")
	+ \|> get("/api/pleroma/emoji/pack?name=test_pack_nonshared")
	\|> json_response_and_validate_schema(200)
	\|> json()

	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_pack2/pack.json")
	assert File.exists?("#{@emoji_path}/test_pack2/blank.png")

	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/test_pack2")
	+ \|> delete("/api/pleroma/emoji/pack?name=test_pack2")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_pack2")

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/emoji/packs/download",
	%{
	url: "https://example.com",
	name: "test_pack_nonshared",
	as: "test_pack_nonshared2"
	}
	)
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_pack_nonshared2/pack.json")
	assert File.exists?("#{@emoji_path}/test_pack_nonshared2/blank.png")

	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/test_pack_nonshared2")
	+ \|> delete("/api/pleroma/emoji/pack?name=test_pack_nonshared2")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_pack_nonshared2")
	end

	test "nonshareable instance", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://old-instance/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://old-instance/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://old-instance/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: []}})
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post(
	"/api/pleroma/emoji/packs/download",
	%{
	url: "https://old-instance",
	name: "test_pack",
	as: "test_pack2"
	}
	)
	\|> json_response_and_validate_schema(500) == %{
	"error" => "The requested instance does not support sharing emoji packs"
	}
	end

	test "checksum fail", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	- url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha"
	+ url: "https://example.com/api/pleroma/emoji/pack?name=pack_bad_sha"
	} ->
	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("pack_bad_sha")
	%Tesla.Env{status: 200, body: Jason.encode!(pack)}

	%{
	method: :get,
	- url: "https://example.com/api/pleroma/emoji/packs/pack_bad_sha/archive"
	+ url: "https://example.com/api/pleroma/emoji/packs/archive?name=pack_bad_sha"
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/instance_static/emoji/pack_bad_sha/pack_bad_sha.zip")
	}
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "pack_bad_sha",
	as: "pack_bad_sha2"
	})
	\|> json_response_and_validate_schema(:internal_server_error) == %{
	"error" => "SHA256 for the pack doesn't match the one sent by the server"
	}
	end

	test "other error", %{admin_conn: admin_conn} do
	mock(fn
	%{method: :get, url: "https://example.com/.well-known/nodeinfo"} ->
	json(%{links: [%{href: "https://example.com/nodeinfo/2.1.json"}]})

	%{method: :get, url: "https://example.com/nodeinfo/2.1.json"} ->
	json(%{metadata: %{features: ["shareable_emoji_packs"]}})

	%{
	method: :get,
	- url: "https://example.com/api/pleroma/emoji/packs/test_pack"
	+ url: "https://example.com/api/pleroma/emoji/pack?name=test_pack"
	} ->
	{:ok, pack} = Pleroma.Emoji.Pack.load_pack("test_pack")
	%Tesla.Env{status: 200, body: Jason.encode!(pack)}
	end)

	assert admin_conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/pleroma/emoji/packs/download", %{
	url: "https://example.com",
	name: "test_pack",
	as: "test_pack2"
	})
	\|> json_response_and_validate_schema(:internal_server_error) == %{
	"error" =>
	"The pack was not set as shared and there is no fallback src to download from"
	}
	end
	end

	- describe "PATCH /api/pleroma/emoji/packs/:name" do
	+ describe "PATCH /api/pleroma/emoji/pack?name=:name" do
	setup do
	pack_file = "#{@emoji_path}/test_pack/pack.json"
	original_content = File.read!(pack_file)

	on_exit(fn ->
	File.write!(pack_file, original_content)
	end)

	{:ok,
	pack_file: pack_file,
	new_data: %{
	"license" => "Test license changed",
	"homepage" => "https://pleroma.social",
	"description" => "Test description",
	"share-files" => false
	}}
	end

	test "for a pack without a fallback source", ctx do
	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack", %{"metadata" => ctx[:new_data]})
	+ \|> patch("/api/pleroma/emoji/pack?name=test_pack", %{
	+ "metadata" => ctx[:new_data]
	+ })
	\|> json_response_and_validate_schema(200) == ctx[:new_data]

	assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == ctx[:new_data]
	end

	test "for a pack with a fallback source", ctx do
	mock(fn
	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	text(File.read!("#{@emoji_path}/test_pack_nonshared/nonshared.zip"))
	end)

	new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")

	new_data_with_sha =
	Map.put(
	new_data,
	"fallback-src-sha256",
	"1967BB4E42BCC34BCC12D57BE7811D3B7BE52F965BCE45C87BD377B9499CE11D"
	)

	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack", %{metadata: new_data})
	+ \|> patch("/api/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
	\|> json_response_and_validate_schema(200) == new_data_with_sha

	assert Jason.decode!(File.read!(ctx[:pack_file]))["pack"] == new_data_with_sha
	end

	test "when the fallback source doesn't have all the files", ctx do
	mock(fn
	%{
	method: :get,
	url: "https://nonshared-pack"
	} ->
	{:ok, {'empty.zip', empty_arch}} = :zip.zip('empty.zip', [], [:memory])
	text(empty_arch)
	end)

	new_data = Map.put(ctx[:new_data], "fallback-src", "https://nonshared-pack")

	assert ctx[:admin_conn]
	\|> put_req_header("content-type", "multipart/form-data")
	- \|> patch("/api/pleroma/emoji/packs/test_pack", %{metadata: new_data})
	+ \|> patch("/api/pleroma/emoji/pack?name=test_pack", %{metadata: new_data})
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "The fallback archive does not have all files specified in pack.json"
	}
	end
	end

	- describe "POST/DELETE /api/pleroma/emoji/packs/:name" do
	+ describe "POST/DELETE /api/pleroma/emoji/pack?name=:name" do
	test "creating and deleting a pack", %{admin_conn: admin_conn} do
	assert admin_conn
	- \|> post("/api/pleroma/emoji/packs/test_created")
	+ \|> post("/api/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(200) == "ok"

	assert File.exists?("#{@emoji_path}/test_created/pack.json")

	assert Jason.decode!(File.read!("#{@emoji_path}/test_created/pack.json")) == %{
	"pack" => %{},
	"files" => %{},
	"files_count" => 0
	}

	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/test_created")
	+ \|> delete("/api/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(200) == "ok"

	refute File.exists?("#{@emoji_path}/test_created/pack.json")
	end

	test "if pack exists", %{admin_conn: admin_conn} do
	path = Path.join(@emoji_path, "test_created")
	File.mkdir(path)
	pack_file = Jason.encode!(%{files: %{}, pack: %{}})
	File.write!(Path.join(path, "pack.json"), pack_file)

	assert admin_conn
	- \|> post("/api/pleroma/emoji/packs/test_created")
	+ \|> post("/api/pleroma/emoji/pack?name=test_created")
	\|> json_response_and_validate_schema(:conflict) == %{
	"error" => "A pack named \"test_created\" already exists"
	}

	on_exit(fn -> File.rm_rf(path) end)
	end

	test "with empty name", %{admin_conn: admin_conn} do
	assert admin_conn
	- \|> post("/api/pleroma/emoji/packs/ ")
	+ \|> post("/api/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end
	end

	test "deleting nonexisting pack", %{admin_conn: admin_conn} do
	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/non_existing")
	+ \|> delete("/api/pleroma/emoji/pack?name=non_existing")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack non_existing does not exist"
	}
	end

	test "deleting with empty name", %{admin_conn: admin_conn} do
	assert admin_conn
	- \|> delete("/api/pleroma/emoji/packs/ ")
	+ \|> delete("/api/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end

	test "filesystem import", %{admin_conn: admin_conn, conn: conn} do
	on_exit(fn ->
	File.rm!("#{@emoji_path}/test_pack_for_import/emoji.txt")
	File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
	end)

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	refute Map.has_key?(resp["packs"], "test_pack_for_import")

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/import")
	\|> json_response_and_validate_schema(200) == ["test_pack_for_import"]

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)
	assert resp["packs"]["test_pack_for_import"]["files"] == %{"blank" => "blank.png"}

	File.rm!("#{@emoji_path}/test_pack_for_import/pack.json")
	refute File.exists?("#{@emoji_path}/test_pack_for_import/pack.json")

	emoji_txt_content = """
	blank, blank.png, Fun
	blank2, blank.png
	foo, /emoji/test_pack_for_import/blank.png
	bar
	"""

	File.write!("#{@emoji_path}/test_pack_for_import/emoji.txt", emoji_txt_content)

	assert admin_conn
	\|> get("/api/pleroma/emoji/packs/import")
	\|> json_response_and_validate_schema(200) == ["test_pack_for_import"]

	resp = conn \|> get("/api/pleroma/emoji/packs") \|> json_response_and_validate_schema(200)

	assert resp["packs"]["test_pack_for_import"]["files"] == %{
	"blank" => "blank.png",
	"blank2" => "blank.png",
	"foo" => "blank.png"
	}
	end

	- describe "GET /api/pleroma/emoji/packs/:name" do
	+ describe "GET /api/pleroma/emoji/pack?name=:name" do
	test "shows pack.json", %{conn: conn} do
	assert %{
	"files" => files,
	"files_count" => 2,
	"pack" => %{
	"can-download" => true,
	"description" => "Test description",
	"download-sha256" => _,
	"homepage" => "https://pleroma.social",
	"license" => "Test license",
	"share-files" => true
	}
	} =
	conn
	- \|> get("/api/pleroma/emoji/packs/test_pack")
	+ \|> get("/api/pleroma/emoji/pack?name=test_pack")
	\|> json_response_and_validate_schema(200)

	assert files == %{"blank" => "blank.png", "blank2" => "blank2.png"}

	assert %{
	"files" => files,
	"files_count" => 2
	} =
	conn
	- \|> get("/api/pleroma/emoji/packs/test_pack?page_size=1")
	+ \|> get("/api/pleroma/emoji/pack?name=test_pack&page_size=1")
	\|> json_response_and_validate_schema(200)

	assert files \|> Map.keys() \|> length() == 1

	assert %{
	"files" => files,
	"files_count" => 2
	} =
	conn
	- \|> get("/api/pleroma/emoji/packs/test_pack?page_size=1&page=2")
	+ \|> get("/api/pleroma/emoji/pack?name=test_pack&page_size=1&page=2")
	\|> json_response_and_validate_schema(200)

	assert files \|> Map.keys() \|> length() == 1
	end

	+ test "for pack name with special chars", %{conn: conn} do
	+ assert %{
	+ "files" => files,
	+ "files_count" => 1,
	+ "pack" => %{
	+ "can-download" => true,
	+ "description" => "Test description",
	+ "download-sha256" => _,
	+ "homepage" => "https://pleroma.social",
	+ "license" => "Test license",
	+ "share-files" => true
	+ }
	+ } =
	+ conn
	+ \|> get("/api/pleroma/emoji/pack?name=blobs.gg")
	+ \|> json_response_and_validate_schema(200)
	+ end
	+
	test "non existing pack", %{conn: conn} do
	assert conn
	- \|> get("/api/pleroma/emoji/packs/non_existing")
	+ \|> get("/api/pleroma/emoji/pack?name=non_existing")
	\|> json_response_and_validate_schema(:not_found) == %{
	"error" => "Pack non_existing does not exist"
	}
	end

	test "error name", %{conn: conn} do
	assert conn
	- \|> get("/api/pleroma/emoji/packs/ ")
	+ \|> get("/api/pleroma/emoji/pack?name= ")
	\|> json_response_and_validate_schema(:bad_request) == %{
	"error" => "pack name cannot be empty"
	}
	end
	end
	end
	diff --git a/test/web/push/impl_test.exs b/test/web/push/impl_test.exs
	index c7c17e156..6cab46696 100644
	--- a/test/web/push/impl_test.exs
	+++ b/test/web/push/impl_test.exs
	@@ -1,362 +1,344 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.ImplTest do
	use Pleroma.DataCase

	+ import Pleroma.Factory
	+
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Push.Impl
	alias Pleroma.Web.Push.Subscription
	- alias Pleroma.Web.WebPushHttpClientMock
	-
	- import Mock
	- import Pleroma.Factory

	setup do
	Tesla.Mock.mock(fn
	%{method: :post, url: "https://example.com/example/1234"} ->
	%Tesla.Env{status: 200}

	%{method: :post, url: "https://example.com/example/not_found"} ->
	%Tesla.Env{status: 400}

	%{method: :post, url: "https://example.com/example/bad"} ->
	%Tesla.Env{status: 100}
	end)

	:ok
	end

	@sub %{
	endpoint: "https://example.com/example/1234",
	keys: %{
	auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA="
	}
	}
	@api_key "BASgACIHpN1GYgzSRp"
	@message "@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	test "performs sending notifications" do
	user = insert(:user)
	user2 = insert(:user)
	insert(:push_subscription, user: user, data: %{alerts: %{"mention" => true}})
	insert(:push_subscription, user: user2, data: %{alerts: %{"mention" => true}})

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => true}}
	)

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => false}}
	)

	{:ok, activity} = CommonAPI.post(user, %{status: "<Lorem ipsum dolor sit amet."})

	notif =
	insert(:notification,
	user: user,
	activity: activity,
	type: "mention"
	)

	assert Impl.perform(notif) == {:ok, [:ok, :ok]}
	end

	@tag capture_log: true
	test "returns error if notif does not match " do
	assert Impl.perform(%{}) == {:error, :unknown_type}
	end

	test "successful message sending" do
	assert Impl.push_message(@message, @sub, @api_key, %Subscription{}) == :ok
	end

	- test_with_mock "uses WebPushHttpClientMock as an HTTP client", WebPushHttpClientMock,
	- post: fn _, _, _ -> {:ok, %{status_code: 200}} end do
	- Impl.push_message(@message, @sub, @api_key, %Subscription{})
	- assert_called(WebPushHttpClientMock.post("https://example.com/example/1234", :_, :_))
	- end
	-
	- test_with_mock "uses Pleroma.HTTP as an HTTP client", Pleroma.HTTP,
	- post: fn _, _, _ -> {:ok, %{status_code: 200}} end do
	- client = Application.get_env(:web_push_encryption, :http_client)
	- on_exit(fn -> Application.put_env(:web_push_encryption, :http_client, client) end)
	- Application.put_env(:web_push_encryption, :http_client, Pleroma.HTTP)
	-
	- Impl.push_message(@message, @sub, @api_key, %Subscription{})
	- assert_called(Pleroma.HTTP.post("https://example.com/example/1234", :_, :_))
	- end
	-
	@tag capture_log: true
	test "fail message sending" do
	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/bad"}),
	@api_key,
	%Subscription{}
	) == :error
	end

	test "delete subscription if result send message between 400..500" do
	subscription = insert(:push_subscription)

	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/not_found"}),
	@api_key,
	subscription
	) == :ok

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "deletes subscription when token has been deleted" do
	subscription = insert(:push_subscription)

	Pleroma.Repo.delete(subscription.token)

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "renders title and body for create activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	object = Object.normalize(activity)

	assert Impl.format_body(
	%{
	activity: activity
	},
	user,
	object
	) ==
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	assert Impl.format_title(%{activity: activity, type: "mention"}) ==
	"New Mention"
	end

	test "renders title and body for follow activity" do
	user = insert(:user, nickname: "Bob")
	other_user = insert(:user)
	{:ok, _, _, activity} = CommonAPI.follow(user, other_user)
	object = Object.normalize(activity, false)

	assert Impl.format_body(%{activity: activity, type: "follow"}, user, object) ==
	"@Bob has followed you"

	assert Impl.format_title(%{activity: activity, type: "follow"}) ==
	"New Follower"
	end

	test "renders title and body for announce activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, announce_activity} = CommonAPI.repeat(activity.id, user)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: announce_activity}, user, object) ==
	"@#{user.nickname} repeated: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	assert Impl.format_title(%{activity: announce_activity, type: "reblog"}) ==
	"New Repeat"
	end

	test "renders title and body for like activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, activity} = CommonAPI.favorite(user, activity.id)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: activity, type: "favourite"}, user, object) ==
	"@Bob has favorited your post"

	assert Impl.format_title(%{activity: activity, type: "favourite"}) ==
	"New Favorite"
	end

	test "renders title for create activity with direct visibility" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "This is just between you and me, pal"
	})

	assert Impl.format_title(%{activity: activity}) ==
	"New Direct Message"
	end

	describe "build_content/3" do
	test "builds content for chat messages" do
	user = insert(:user)
	recipient = insert(:user)

	{:ok, chat} = CommonAPI.post_chat_message(user, recipient, "hey")
	object = Object.normalize(chat, false)
	[notification] = Notification.for_user(recipient)

	res = Impl.build_content(notification, user, object)

	assert res == %{
	body: "@#{user.nickname}: hey",
	title: "New Chat Message"
	}
	end

	test "builds content for chat messages with no content" do
	user = insert(:user)
	recipient = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)

	{:ok, chat} = CommonAPI.post_chat_message(user, recipient, nil, media_id: upload.id)
	object = Object.normalize(chat, false)
	[notification] = Notification.for_user(recipient)

	res = Impl.build_content(notification, user, object)

	assert res == %{
	body: "@#{user.nickname}: (Attachment)",
	title: "New Chat Message"
	}
	end

	test "hides contents of notifications when option enabled" do
	user = insert(:user, nickname: "Bob")

	user2 =
	insert(:user, nickname: "Rob", notification_settings: %{hide_notification_contents: true})

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status: "<Lorem ipsum dolor sit amet."
	})

	notif = insert(:notification, user: user2, activity: activity)

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Direct Message"
	}

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "public",
	status: "<Lorem ipsum dolor sit amet."
	})

	notif = insert(:notification, user: user2, activity: activity, type: "mention")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Mention"
	}

	{:ok, activity} = CommonAPI.favorite(user, activity.id)

	notif = insert(:notification, user: user2, activity: activity, type: "favourite")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "New Favorite"
	}
	end

	test "returns regular content when hiding contents option disabled" do
	user = insert(:user, nickname: "Bob")

	user2 =
	insert(:user, nickname: "Rob", notification_settings: %{hide_notification_contents: false})

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "direct",
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	notif = insert(:notification, user: user2, activity: activity)

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body:
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini...",
	title: "New Direct Message"
	}

	{:ok, activity} =
	CommonAPI.post(user, %{
	visibility: "public",
	status:
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	notif = insert(:notification, user: user2, activity: activity, type: "mention")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body:
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini...",
	title: "New Mention"
	}

	{:ok, activity} = CommonAPI.favorite(user, activity.id)

	notif = insert(:notification, user: user2, activity: activity, type: "favourite")

	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	object = Object.normalize(activity)

	assert Impl.build_content(notif, actor, object) == %{
	body: "@Bob has favorited your post",
	title: "New Favorite"
	}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 9:53 AM (17 h, 52 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1800002
Default Alt Text: (797 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions