No OneTemporary
Actions

Size

492 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 aad28a2d8..b4bd59b43 100644
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -1,335 +1,330 @@
	-image: elixir:1.8.1
	+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:
	- 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:
	- 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:
	- 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
	- # TODO: Replace with upstream image when 1.9.0 comes out
	- image: rinpatch/elixir:1.9.0-rc.0
	+ 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
	- 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
	- # TODO: Replace with upstream image when 1.9.0 comes out
	- image: rinpatch/elixir:1.9.0-rc.0-alpine
	+ 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
	- 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
	- # TODO: Replace with upstream image when 1.9.0 comes out
	- image: rinpatch/elixir:1.9.0-rc.0-arm
	+ 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
	- # TODO: Replace with upstream image when 1.9.0 comes out
	- image: rinpatch/elixir:1.9.0-rc.0-arm-alpine
	+ 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
	- # TODO: Replace with upstream image when 1.9.0 comes out
	- image: rinpatch/elixir:1.9.0-rc.0-arm64
	+ 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: rinpatch/elixir:1.9.0-rc.0-arm64-alpine
	+ 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
	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:
	- docker build --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 .
	- docker push $IMAGE_TAG
	- docker push $IMAGE_TAG_SLUG
	- docker push $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:
	- docker build --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 .
	- docker push $IMAGE_TAG
	- docker push $IMAGE_TAG_SLUG
	- docker push $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:
	- docker build --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 .
	- docker push $IMAGE_TAG
	- docker push $IMAGE_TAG_SLUG
	tags:
	- dind
	only:
	- /^release/.*$/@pleroma/pleroma
	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index d2629bf84..3ee13904f 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,723 +1,725 @@
	# Changelog
	All notable changes to this project will be documented in this file.

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

	## [unreleased]

	### Changed
	+- Breaking: Elixir >=1.9 is now required (was >= 1.8)
	+- In Conversations, return only direct messages as `last_status`
	- MFR policy to set global expiration for all local Create activities
	- OGP rich media parser merged with TwitterCard
	<details>
	<summary>API Changes</summary>
	- Breaking: Emoji API: changed methods and renamed routes.
	</details>

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

	### Added
	- 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
	<details>
	<summary>API Changes</summary>
	- Mastodon API: Extended `/api/v1/instance`.
	- Mastodon API: Support for `include_types` in `/api/v1/notifications`.
	- Mastodon API: Added `/api/v1/notifications/:id/dismiss` endpoint.
	- Mastodon API: Add support for filtering replies in public and home timelines
	- Admin API: endpoints for create/update/delete OAuth Apps.
	- Admin API: endpoint for status view.
	- OTP: Add command to reload emoji packs
	</details>

	### Fixed
	- Support pagination in conversations API
	- Breaking: SimplePolicy `:reject` and `:accept` allow deletions again
	- Fix follower/blocks import when nicknames starts with @
	- Filtering of push notifications on activities from blocked domains
	- Resolving Peertube accounts with Webfinger
	- `blob:` urls not being allowed by connect-src CSP
	- Mastodon API: fix `GET /api/v1/notifications` not returning the full result set

	## [Unreleased (patch)]

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

	## [2.0.3] - 2020-05-02

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

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

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

	### Upgrade notes

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


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

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

	### Upgrade notes
	1. Restart Pleroma

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	### Added
	- Integrated captcha provider

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	## [0.9.9] - 2019-02-22
	This is our first stable release.
	diff --git a/elixir_buildpack.config b/elixir_buildpack.config
	index c23b08fb8..946408c12 100644
	--- a/elixir_buildpack.config
	+++ b/elixir_buildpack.config
	@@ -1,2 +1,2 @@
	-elixir_version=1.8.2
	-erlang_version=21.3.7
	+elixir_version=1.9.4
	+erlang_version=22.3.4.1
	diff --git a/lib/mix/tasks/pleroma/config.ex b/lib/mix/tasks/pleroma/config.ex
	index 5c9ef6904..f1b3a8766 100644
	--- a/lib/mix/tasks/pleroma/config.ex
	+++ b/lib/mix/tasks/pleroma/config.ex
	@@ -1,150 +1,146 @@
	# 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.Config do
	use Mix.Task

	import Mix.Pleroma

	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	@shortdoc "Manages the location of the config"
	@moduledoc File.read!("docs/administration/CLI_tasks/config.md")

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

	def run(["migrate_from_db" \| options]) do
	start_pleroma()

	{opts, _} =
	OptionParser.parse!(options,
	strict: [env: :string, delete: :boolean],
	aliases: [d: :delete]
	)

	migrate_from_db(opts)
	end

	@spec migrate_to_db(Path.t() \| nil) :: any()
	def migrate_to_db(file_path \\ nil) do
	if Pleroma.Config.get([:configurable_from_database]) do
	config_file =
	if file_path do
	file_path
	else
	if Pleroma.Config.get(:release) do
	Pleroma.Config.get(:config_path)
	else
	"config/#{Pleroma.Config.get(:env)}.secret.exs"
	end
	end

	do_migrate_to_db(config_file)
	else
	migration_error()
	end
	end

	defp do_migrate_to_db(config_file) do
	if File.exists?(config_file) do
	Ecto.Adapters.SQL.query!(Repo, "TRUNCATE config;")
	Ecto.Adapters.SQL.query!(Repo, "ALTER SEQUENCE config_id_seq RESTART;")

	custom_config =
	config_file
	\|> read_file()
	\|> elem(0)

	custom_config
	\|> Keyword.keys()
	\|> Enum.each(&create(&1, custom_config))
	else
	shell_info("To migrate settings, you must define custom settings in #{config_file}.")
	end
	end

	defp create(group, settings) do
	group
	\|> Pleroma.Config.Loader.filter_group(settings)
	\|> Enum.each(fn {key, value} ->
	- key = inspect(key)
	- {:ok, _} = ConfigDB.update_or_create(%{group: inspect(group), key: key, value: value})
	+ {:ok, _} = ConfigDB.update_or_create(%{group: group, key: key, value: value})

	shell_info("Settings for key #{key} migrated.")
	end)

	shell_info("Settings for group :#{group} migrated.")
	end

	defp migrate_from_db(opts) do
	if Pleroma.Config.get([:configurable_from_database]) do
	env = opts[:env] \|\| "prod"

	config_path =
	if Pleroma.Config.get(:release) do
	:config_path
	\|> Pleroma.Config.get()
	\|> Path.dirname()
	else
	"config"
	end
	\|> Path.join("#{env}.exported_from_db.secret.exs")

	file = File.open!(config_path, [:write, :utf8])

	IO.write(file, config_header())

	ConfigDB
	\|> Repo.all()
	\|> Enum.each(&write_and_delete(&1, file, opts[:delete]))

	:ok = File.close(file)
	System.cmd("mix", ["format", config_path])
	else
	migration_error()
	end
	end

	defp migration_error do
	shell_error(
	"Migration is not allowed in config. You can change this behavior by setting `configurable_from_database` to true."
	)
	end

	if Code.ensure_loaded?(Config.Reader) do
	defp config_header, do: "import Config\r\n\r\n"
	defp read_file(config_file), do: Config.Reader.read_imports!(config_file)
	else
	defp config_header, do: "use Mix.Config\r\n\r\n"
	defp read_file(config_file), do: Mix.Config.eval!(config_file)
	end

	defp write_and_delete(config, file, delete?) do
	config
	\|> write(file)
	\|> delete(delete?)
	end

	defp write(config, file) do
	- value =
	- config.value
	- \|> ConfigDB.from_binary()
	- \|> inspect(limit: :infinity)
	+ value = inspect(config.value, limit: :infinity)

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

	config
	end

	defp delete(config, true) do
	{:ok, _} = Repo.delete(config)
	shell_info("#{config.key} deleted from DB.")
	end

	defp delete(_config, _), do: :ok
	end
	diff --git a/lib/pleroma/config/config_db.ex b/lib/pleroma/config/config_db.ex
	index 2b43d4c36..2f4eb8581 100644
	--- a/lib/pleroma/config/config_db.ex
	+++ b/lib/pleroma/config/config_db.ex
	@@ -1,414 +1,381 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConfigDB do
	use Ecto.Schema

	import Ecto.Changeset
	- import Ecto.Query
	+ import Ecto.Query, only: [select: 3]
	import Pleroma.Web.Gettext

	alias __MODULE__
	alias Pleroma.Repo

	@type t :: %__MODULE__{}

	- @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}
	- ]
	-
	@full_subkey_update [
	{:pleroma, :assets, :mascots},
	{:pleroma, :emoji, :groups},
	{:pleroma, :workers, :retries},
	{:pleroma, :mrf_subchain, :match_actor},
	{:pleroma, :mrf_keyword, :replace}
	]

	- @regex ~r/^~r(?'delimiter'[\/\|"'([{<]{1})(?'pattern'.+)[\/\|"')\]}>]{1}(?'modifier'[uismxfU]*)/u
	-
	- @delimiters ["/", "\|", "\"", "'", {"(", ")"}, {"[", "]"}, {"{", "}"}, {"<", ">"}]
	-
	schema "config" do
	- field(:key, :string)
	- field(:group, :string)
	- field(:value, :binary)
	+ field(:key, Pleroma.EctoType.Config.Atom)
	+ field(:group, Pleroma.EctoType.Config.Atom)
	+ field(:value, Pleroma.EctoType.Config.BinaryValue)
	field(:db, {:array, :string}, virtual: true, default: [])

	timestamps()
	end

	@spec get_all_as_keyword() :: keyword()
	def get_all_as_keyword do
	ConfigDB
	\|> select([c], {c.group, c.key, c.value})
	\|> Repo.all()
	\|> Enum.reduce([], fn {group, key, value}, acc ->
	- group = ConfigDB.from_string(group)
	- key = ConfigDB.from_string(key)
	- value = from_binary(value)
	-
	Keyword.update(acc, group, [{key, value}], &Keyword.merge(&1, [{key, value}]))
	end)
	end

	@spec get_by_params(map()) :: ConfigDB.t() \| nil
	def get_by_params(params), do: Repo.get_by(ConfigDB, params)

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

	- @spec create(map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()}
	- def create(params) do
	+ defp create(params) do
	%ConfigDB{}
	\|> changeset(params)
	\|> Repo.insert()
	end

	- @spec update(ConfigDB.t(), map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()}
	- def update(%ConfigDB{} = config, %{value: value}) do
	+ defp update(%ConfigDB{} = config, %{value: value}) do
	config
	\|> changeset(%{value: value})
	\|> Repo.update()
	end

	- @spec get_db_keys(ConfigDB.t()) :: [String.t()]
	- def get_db_keys(%ConfigDB{} = config) do
	- config.value
	- \|> ConfigDB.from_binary()
	- \|> get_db_keys(config.key)
	- end
	-
	@spec get_db_keys(keyword(), any()) :: [String.t()]
	def get_db_keys(value, key) do
	- if Keyword.keyword?(value) do
	- value \|> Keyword.keys() \|> Enum.map(&convert(&1))
	- else
	- [convert(key)]
	- end
	+ keys =
	+ if Keyword.keyword?(value) do
	+ Keyword.keys(value)
	+ else
	+ [key]
	+ end
	+
	+ Enum.map(keys, &to_json_types(&1))
	end

	@spec merge_group(atom(), atom(), keyword(), keyword()) :: keyword()
	def merge_group(group, key, old_value, new_value) do
	- new_keys = to_map_set(new_value)
	+ new_keys = to_mapset(new_value)

	- intersect_keys =
	- old_value \|> to_map_set() \|> MapSet.intersection(new_keys) \|> MapSet.to_list()
	+ intersect_keys = old_value \|> to_mapset() \|> MapSet.intersection(new_keys) \|> MapSet.to_list()

	merged_value = ConfigDB.merge(old_value, new_value)

	@full_subkey_update
	\|> Enum.map(fn
	{g, k, subkey} when g == group and k == key ->
	if subkey in intersect_keys, do: subkey, else: []

	_ ->
	[]
	end)
	\|> List.flatten()
	- \|> Enum.reduce(merged_value, fn subkey, acc ->
	- Keyword.put(acc, subkey, new_value[subkey])
	- end)
	+ \|> Enum.reduce(merged_value, &Keyword.put(&2, &1, new_value[&1]))
	end

	- defp to_map_set(keyword) do
	+ defp to_mapset(keyword) do
	keyword
	\|> Keyword.keys()
	\|> MapSet.new()
	end

	@spec sub_key_full_update?(atom(), atom(), [Keyword.key()]) :: boolean()
	def sub_key_full_update?(group, key, subkeys) do
	Enum.any?(@full_subkey_update, fn {g, k, subkey} ->
	g == group and k == key and subkey in subkeys
	end)
	end

	@spec merge(keyword(), keyword()) :: keyword()
	def merge(config1, config2) when is_list(config1) and is_list(config2) do
	Keyword.merge(config1, config2, fn _, app1, app2 ->
	if Keyword.keyword?(app1) and Keyword.keyword?(app2) do
	Keyword.merge(app1, app2, &deep_merge/3)
	else
	app2
	end
	end)
	end

	defp deep_merge(_key, value1, value2) do
	if Keyword.keyword?(value1) and Keyword.keyword?(value2) do
	Keyword.merge(value1, value2, &deep_merge/3)
	else
	value2
	end
	end

	@spec update_or_create(map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()}
	def update_or_create(params) do
	+ params = Map.put(params, :value, to_elixir_types(params[:value]))
	search_opts = Map.take(params, [:group, :key])

	with %ConfigDB{} = config <- ConfigDB.get_by_params(search_opts),
	- {:partial_update, true, config} <-
	- {:partial_update, can_be_partially_updated?(config), config},
	- old_value <- from_binary(config.value),
	- transformed_value <- do_transform(params[:value]),
	- {:can_be_merged, true, config} <- {:can_be_merged, is_list(transformed_value), config},
	- new_value <-
	- merge_group(
	- ConfigDB.from_string(config.group),
	- ConfigDB.from_string(config.key),
	- old_value,
	- transformed_value
	- ) do
	- ConfigDB.update(config, %{value: new_value})
	+ {_, true, config} <- {:partial_update, can_be_partially_updated?(config), config},
	+ {_, true, config} <-
	+ {:can_be_merged, is_list(params[:value]) and is_list(config.value), config} do
	+ new_value = merge_group(config.group, config.key, config.value, params[:value])
	+ update(config, %{value: new_value})
	else
	{reason, false, config} when reason in [:partial_update, :can_be_merged] ->
	- ConfigDB.update(config, params)
	+ update(config, params)

	nil ->
	- ConfigDB.create(params)
	+ create(params)
	end
	end

	defp can_be_partially_updated?(%ConfigDB{} = config), do: not only_full_update?(config)

	- defp only_full_update?(%ConfigDB{} = config) do
	- config_group = ConfigDB.from_string(config.group)
	- config_key = ConfigDB.from_string(config.key)
	-
	- Enum.any?(@full_key_update, fn
	- {group, key} when is_list(key) ->
	- config_group == group and config_key in key
	-
	- {group, key} ->
	- config_group == group and config_key == key
	+ defp only_full_update?(%ConfigDB{group: group, key: key}) do
	+ 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}
	+ ]
	+
	+ Enum.any?(full_key_update, fn
	+ {s_group, s_key} ->
	+ group == s_group and ((is_list(s_key) and key in s_key) or key == s_key)
	end)
	end

	@spec delete(map()) :: {:ok, ConfigDB.t()} \| {:error, Changeset.t()}
	def delete(params) do
	search_opts = Map.delete(params, :subkeys)

	with %ConfigDB{} = config <- ConfigDB.get_by_params(search_opts),
	{config, sub_keys} when is_list(sub_keys) <- {config, params[:subkeys]},
	- old_value <- from_binary(config.value),
	- keys <- Enum.map(sub_keys, &do_transform_string(&1)),
	- {:partial_remove, config, new_value} when new_value != [] <-
	- {:partial_remove, config, Keyword.drop(old_value, keys)} do
	- ConfigDB.update(config, %{value: new_value})
	+ keys <- Enum.map(sub_keys, &string_to_elixir_types(&1)),
	+ {_, config, new_value} when new_value != [] <-
	+ {:partial_remove, config, Keyword.drop(config.value, keys)} do
	+ update(config, %{value: new_value})
	else
	{:partial_remove, config, []} ->
	Repo.delete(config)

	{config, nil} ->
	Repo.delete(config)

	nil ->
	err =
	dgettext("errors", "Config with params %{params} not found", params: inspect(params))

	{:error, err}
	end
	end

	- @spec from_binary(binary()) :: term()
	- def from_binary(binary), do: :erlang.binary_to_term(binary)
	-
	- @spec from_binary_with_convert(binary()) :: any()
	- def from_binary_with_convert(binary) do
	- binary
	- \|> from_binary()
	- \|> do_convert()
	+ @spec to_json_types(term()) :: map() \| list() \| boolean() \| String.t()
	+ def to_json_types(entity) when is_list(entity) do
	+ Enum.map(entity, &to_json_types/1)
	end

	- @spec from_string(String.t()) :: atom() \| no_return()
	- def from_string(string), do: do_transform_string(string)
	+ def to_json_types(%Regex{} = entity), do: inspect(entity)

	- @spec convert(any()) :: any()
	- def convert(entity), do: do_convert(entity)
	-
	- defp do_convert(entity) when is_list(entity) do
	- for v <- entity, into: [], do: do_convert(v)
	+ def to_json_types(entity) when is_map(entity) do
	+ Map.new(entity, fn {k, v} -> {to_json_types(k), to_json_types(v)} end)
	end

	- defp do_convert(%Regex{} = entity), do: inspect(entity)
	+ def to_json_types({:args, args}) when is_list(args) do
	+ arguments =
	+ Enum.map(args, fn
	+ arg when is_tuple(arg) -> inspect(arg)
	+ arg -> to_json_types(arg)
	+ end)

	- defp do_convert(entity) when is_map(entity) do
	- for {k, v} <- entity, into: %{}, do: {do_convert(k), do_convert(v)}
	+ %{"tuple" => [":args", arguments]}
	end

	- defp do_convert({:proxy_url, {type, :localhost, port}}) do
	- %{"tuple" => [":proxy_url", %{"tuple" => [do_convert(type), "localhost", port]}]}
	+ def to_json_types({:proxy_url, {type, :localhost, port}}) do
	+ %{"tuple" => [":proxy_url", %{"tuple" => [to_json_types(type), "localhost", port]}]}
	end

	- defp do_convert({:proxy_url, {type, host, port}}) when is_tuple(host) do
	+ def to_json_types({:proxy_url, {type, host, port}}) when is_tuple(host) do
	ip =
	host
	\|> :inet_parse.ntoa()
	\|> to_string()

	%{
	"tuple" => [
	":proxy_url",
	- %{"tuple" => [do_convert(type), ip, port]}
	+ %{"tuple" => [to_json_types(type), ip, port]}
	]
	}
	end

	- defp do_convert({:proxy_url, {type, host, port}}) do
	+ def to_json_types({:proxy_url, {type, host, port}}) do
	%{
	"tuple" => [
	":proxy_url",
	- %{"tuple" => [do_convert(type), to_string(host), port]}
	+ %{"tuple" => [to_json_types(type), to_string(host), port]}
	]
	}
	end

	- defp do_convert({:partial_chain, entity}), do: %{"tuple" => [":partial_chain", inspect(entity)]}
	+ def to_json_types({:partial_chain, entity}),
	+ do: %{"tuple" => [":partial_chain", inspect(entity)]}

	- defp do_convert(entity) when is_tuple(entity) do
	+ def to_json_types(entity) when is_tuple(entity) do
	value =
	entity
	\|> Tuple.to_list()
	- \|> do_convert()
	+ \|> to_json_types()

	%{"tuple" => value}
	end

	- defp do_convert(entity) when is_boolean(entity) or is_number(entity) or is_nil(entity) do
	+ def to_json_types(entity) when is_binary(entity), do: entity
	+
	+ def to_json_types(entity) when is_boolean(entity) or is_number(entity) or is_nil(entity) do
	entity
	end

	- defp do_convert(entity)
	- when is_atom(entity) and entity in [:"tlsv1.1", :"tlsv1.2", :"tlsv1.3"] do
	+ def to_json_types(entity) when entity in [:"tlsv1.1", :"tlsv1.2", :"tlsv1.3"] do
	":#{entity}"
	end

	- defp do_convert(entity) when is_atom(entity), do: inspect(entity)
	+ def to_json_types(entity) when is_atom(entity), do: inspect(entity)

	- defp do_convert(entity) when is_binary(entity), do: entity
	+ @spec to_elixir_types(boolean() \| String.t() \| map() \| list()) :: term()
	+ def to_elixir_types(%{"tuple" => [":args", args]}) when is_list(args) do
	+ arguments =
	+ Enum.map(args, fn arg ->
	+ if String.contains?(arg, ["{", "}"]) do
	+ {elem, []} = Code.eval_string(arg)
	+ elem
	+ else
	+ to_elixir_types(arg)
	+ end
	+ end)

	- @spec transform(any()) :: binary() \| no_return()
	- def transform(entity) when is_binary(entity) or is_map(entity) or is_list(entity) do
	- entity
	- \|> do_transform()
	- \|> to_binary()
	+ {:args, arguments}
	end

	- def transform(entity), do: to_binary(entity)
	-
	- @spec transform_with_out_binary(any()) :: any()
	- def transform_with_out_binary(entity), do: do_transform(entity)
	-
	- @spec to_binary(any()) :: binary()
	- def to_binary(entity), do: :erlang.term_to_binary(entity)
	-
	- defp do_transform(%Regex{} = entity), do: entity
	-
	- defp do_transform(%{"tuple" => [":proxy_url", %{"tuple" => [type, host, port]}]}) do
	- {:proxy_url, {do_transform_string(type), parse_host(host), port}}
	+ def to_elixir_types(%{"tuple" => [":proxy_url", %{"tuple" => [type, host, port]}]}) do
	+ {:proxy_url, {string_to_elixir_types(type), parse_host(host), port}}
	end

	- defp do_transform(%{"tuple" => [":partial_chain", entity]}) do
	+ def to_elixir_types(%{"tuple" => [":partial_chain", entity]}) do
	{partial_chain, []} =
	entity
	\|> String.replace(~r/[^\w\|^{:,[\|^,\|^[\|^\]^}\|^\/\|^\.\|^"]^\s/, "")
	\|> Code.eval_string()

	{:partial_chain, partial_chain}
	end

	- defp do_transform(%{"tuple" => entity}) do
	- Enum.reduce(entity, {}, fn val, acc -> Tuple.append(acc, do_transform(val)) end)
	+ def to_elixir_types(%{"tuple" => entity}) do
	+ Enum.reduce(entity, {}, &Tuple.append(&2, to_elixir_types(&1)))
	end

	- defp do_transform(entity) when is_map(entity) do
	- for {k, v} <- entity, into: %{}, do: {do_transform(k), do_transform(v)}
	+ def to_elixir_types(entity) when is_map(entity) do
	+ Map.new(entity, fn {k, v} -> {to_elixir_types(k), to_elixir_types(v)} end)
	end

	- defp do_transform(entity) when is_list(entity) do
	- for v <- entity, into: [], do: do_transform(v)
	+ def to_elixir_types(entity) when is_list(entity) do
	+ Enum.map(entity, &to_elixir_types/1)
	end

	- defp do_transform(entity) when is_binary(entity) do
	+ def to_elixir_types(entity) when is_binary(entity) do
	entity
	\|> String.trim()
	- \|> do_transform_string()
	+ \|> string_to_elixir_types()
	+ end
	+
	+ def to_elixir_types(entity), do: entity
	+
	+ @spec string_to_elixir_types(String.t()) ::
	+ atom() \| Regex.t() \| module() \| String.t() \| no_return()
	+ def string_to_elixir_types("~r" <> _pattern = regex) do
	+ pattern =
	+ ~r/^~r(?'delimiter'[\/\|"'([{<]{1})(?'pattern'.+)[\/\|"')\]}>]{1}(?'modifier'[uismxfU]*)/u
	+
	+ delimiters = ["/", "\|", "\"", "'", {"(", ")"}, {"[", "]"}, {"{", "}"}, {"<", ">"}]
	+
	+ with %{"modifier" => modifier, "pattern" => pattern, "delimiter" => regex_delimiter} <-
	+ Regex.named_captures(pattern, regex),
	+ {:ok, {leading, closing}} <- find_valid_delimiter(delimiters, pattern, regex_delimiter),
	+ {result, _} <- Code.eval_string("~r#{leading}#{pattern}#{closing}#{modifier}") do
	+ result
	+ end
	end

	- defp do_transform(entity), do: entity
	+ def string_to_elixir_types(":" <> atom), do: String.to_atom(atom)
	+
	+ def string_to_elixir_types(value) do
	+ if module_name?(value) do
	+ String.to_existing_atom("Elixir." <> value)
	+ else
	+ value
	+ end
	+ end

	defp parse_host("localhost"), do: :localhost

	defp parse_host(host) do
	charlist = to_charlist(host)

	case :inet.parse_address(charlist) do
	{:error, :einval} ->
	charlist

	{:ok, ip} ->
	ip
	end
	end

	defp find_valid_delimiter([], _string, _) do
	raise(ArgumentError, message: "valid delimiter for Regex expression not found")
	end

	defp find_valid_delimiter([{leading, closing} = delimiter \| others], pattern, regex_delimiter)
	when is_tuple(delimiter) do
	if String.contains?(pattern, closing) do
	find_valid_delimiter(others, pattern, regex_delimiter)
	else
	{:ok, {leading, closing}}
	end
	end

	defp find_valid_delimiter([delimiter \| others], pattern, regex_delimiter) do
	if String.contains?(pattern, delimiter) do
	find_valid_delimiter(others, pattern, regex_delimiter)
	else
	{:ok, {delimiter, delimiter}}
	end
	end

	- defp do_transform_string("~r" <> _pattern = regex) do
	- with %{"modifier" => modifier, "pattern" => pattern, "delimiter" => regex_delimiter} <-
	- Regex.named_captures(@regex, regex),
	- {:ok, {leading, closing}} <- find_valid_delimiter(@delimiters, pattern, regex_delimiter),
	- {result, _} <- Code.eval_string("~r#{leading}#{pattern}#{closing}#{modifier}") do
	- result
	- end
	- end
	-
	- defp do_transform_string(":" <> atom), do: String.to_atom(atom)
	-
	- defp do_transform_string(value) do
	- if is_module_name?(value) do
	- String.to_existing_atom("Elixir." <> value)
	- else
	- value
	- end
	- end
	-
	- @spec is_module_name?(String.t()) :: boolean()
	- def is_module_name?(string) do
	+ @spec module_name?(String.t()) :: boolean()
	+ def module_name?(string) do
	Regex.match?(~r/^(Pleroma\|Phoenix\|Tesla\|Quack\|Ueberauth\|Swoosh)\./, string) or
	string in ["Oban", "Ueberauth", "ExSyslogger"]
	end
	end
	diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
	index c02b70e96..eb86b8ff4 100644
	--- a/lib/pleroma/config/transfer_task.ex
	+++ b/lib/pleroma/config/transfer_task.ex
	@@ -1,209 +1,201 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTask do
	use Task

	alias Pleroma.Config
	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	require Logger

	@type env() :: :test \| :benchmark \| :dev \| :prod

	@reboot_time_keys [
	{:pleroma, :hackney_pools},
	{:pleroma, :chat},
	{:pleroma, Oban},
	{:pleroma, :rate_limit},
	{:pleroma, :markup},
	{:pleroma, :streamer},
	{:pleroma, :pools},
	{:pleroma, :connections_pool}
	]

	@reboot_time_subkeys [
	{:pleroma, Pleroma.Captcha, [:seconds_valid]},
	{:pleroma, Pleroma.Upload, [:proxy_remote]},
	{:pleroma, :instance, [:upload_limit]},
	- {:pleroma, :email_notifications, [:digest]},
	- {:pleroma, :oauth2, [:clean_expired_tokens]},
	- {:pleroma, Pleroma.ActivityExpiration, [:enabled]},
	- {:pleroma, Pleroma.ScheduledActivity, [:enabled]},
	{:pleroma, :gopher, [:enabled]}
	]

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

	@spec load_and_update_env([ConfigDB.t()], boolean()) :: :ok
	def load_and_update_env(deleted_settings \\ [], restart_pleroma? \\ true) do
	with {_, true} <- {:configurable, Config.get(:configurable_from_database)} do
	# We need to restart applications for loaded settings take effect

	{logger, other} =
	(Repo.all(ConfigDB) ++ deleted_settings)
	- \|> Enum.map(&transform_and_merge/1)
	+ \|> Enum.map(&merge_with_default/1)
	\|> Enum.split_with(fn {group, _, _, _} -> group in [:logger, :quack] end)

	logger
	\|> Enum.sort()
	\|> Enum.each(&configure/1)

	started_applications = Application.started_applications()

	# TODO: some problem with prometheus after restart!
	reject = [nil, :prometheus, :postgrex]

	reject =
	if restart_pleroma? do
	reject
	else
	[:pleroma \| reject]
	end

	other
	\|> Enum.map(&update/1)
	\|> Enum.uniq()
	\|> Enum.reject(&(&1 in reject))
	\|> maybe_set_pleroma_last()
	\|> Enum.each(&restart(started_applications, &1, Config.get(:env)))

	:ok
	else
	{:configurable, false} -> Restarter.Pleroma.rebooted()
	end
	end

	defp maybe_set_pleroma_last(apps) do
	# to be ensured that pleroma will be restarted last
	if :pleroma in apps do
	apps
	\|> List.delete(:pleroma)
	\|> List.insert_at(-1, :pleroma)
	else
	Restarter.Pleroma.rebooted()
	apps
	end
	end

	- defp transform_and_merge(%{group: group, key: key, value: value} = setting) do
	- group = ConfigDB.from_string(group)
	- key = ConfigDB.from_string(key)
	- value = ConfigDB.from_binary(value)
	-
	+ defp merge_with_default(%{group: group, key: key, value: value} = setting) do
	default = Config.Holder.default_config(group, key)

	merged =
	cond do
	Ecto.get_meta(setting, :state) == :deleted -> default
	can_be_merged?(default, value) -> ConfigDB.merge_group(group, key, default, value)
	true -> value
	end

	{group, key, value, merged}
	end

	# change logger configuration in runtime, without restart
	defp configure({:quack, key, _, merged}) do
	Logger.configure_backend(Quack.Logger, [{key, merged}])
	:ok = update_env(:quack, key, merged)
	end

	defp configure({_, :backends, _, merged}) do
	# removing current backends
	Enum.each(Application.get_env(:logger, :backends), &Logger.remove_backend/1)

	Enum.each(merged, &Logger.add_backend/1)

	:ok = update_env(:logger, :backends, merged)
	end

	defp configure({_, key, _, merged}) when key in [:console, :ex_syslogger] do
	merged =
	if key == :console do
	put_in(merged[:format], merged[:format] <> "\n")
	else
	merged
	end

	backend =
	if key == :ex_syslogger,
	do: {ExSyslogger, :ex_syslogger},
	else: key

	Logger.configure_backend(backend, merged)
	:ok = update_env(:logger, key, merged)
	end

	defp configure({_, key, _, merged}) do
	Logger.configure([{key, merged}])
	:ok = update_env(:logger, key, merged)
	end

	defp update({group, key, value, merged}) do
	try do
	:ok = update_env(group, key, merged)

	if group != :pleroma or pleroma_need_restart?(group, key, value), do: group
	rescue
	error ->
	error_msg =
	"updating env causes error, group: #{inspect(group)}, key: #{inspect(key)}, value: #{
	inspect(value)
	} error: #{inspect(error)}"

	Logger.warn(error_msg)

	nil
	end
	end

	defp update_env(group, key, nil), do: Application.delete_env(group, key)
	defp update_env(group, key, value), do: Application.put_env(group, key, value)

	@spec pleroma_need_restart?(atom(), atom(), any()) :: boolean()
	def pleroma_need_restart?(group, key, value) do
	group_and_key_need_reboot?(group, key) or group_and_subkey_need_reboot?(group, key, value)
	end

	defp group_and_key_need_reboot?(group, key) do
	Enum.any?(@reboot_time_keys, fn {g, k} -> g == group and k == key end)
	end

	defp group_and_subkey_need_reboot?(group, key, value) do
	Keyword.keyword?(value) and
	Enum.any?(@reboot_time_subkeys, fn {g, k, subkeys} ->
	g == group and k == key and
	Enum.any?(Keyword.keys(value), &(&1 in subkeys))
	end)
	end

	defp restart(_, :pleroma, env), do: Restarter.Pleroma.restart_after_boot(env)

	defp restart(started_applications, app, _) do
	with {^app, _, _} <- List.keyfind(started_applications, app, 0),
	:ok <- Application.stop(app) do
	:ok = Application.start(app)
	else
	nil ->
	Logger.warn("#{app} is not started.")

	error ->
	error
	\|> inspect()
	\|> Logger.warn()
	end
	end

	defp can_be_merged?(val1, val2) when is_list(val1) and is_list(val2) do
	Keyword.keyword?(val1) and Keyword.keyword?(val2)
	end

	defp can_be_merged?(_val1, _val2), do: false
	end
	diff --git a/lib/pleroma/conversation/participation.ex b/lib/pleroma/conversation/participation.ex
	index ce7bd2396..8bc3e85d6 100644
	--- a/lib/pleroma/conversation/participation.ex
	+++ b/lib/pleroma/conversation/participation.ex
	@@ -1,227 +1,230 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Conversation.Participation do
	use Ecto.Schema
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation.RecipientShip
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	import Ecto.Changeset
	import Ecto.Query

	schema "conversation_participations" do
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	belongs_to(:conversation, Conversation)
	field(:read, :boolean, default: false)
	field(:last_activity_id, FlakeId.Ecto.CompatType, virtual: true)

	has_many(:recipient_ships, RecipientShip)
	has_many(:recipients, through: [:recipient_ships, :user])

	timestamps()
	end

	def creation_cng(struct, params) do
	struct
	\|> cast(params, [:user_id, :conversation_id, :read])
	\|> validate_required([:user_id, :conversation_id])
	end

	def create_for_user_and_conversation(user, conversation, opts \\ []) do
	read = !!opts[:read]
	invisible_conversation = !!opts[:invisible_conversation]

	update_on_conflict =
	if(invisible_conversation, do: [], else: [read: read])
	\|> Keyword.put(:updated_at, NaiveDateTime.utc_now())

	%__MODULE__{}
	\|> creation_cng(%{
	user_id: user.id,
	conversation_id: conversation.id,
	read: invisible_conversation \|\| read
	})
	\|> Repo.insert(
	on_conflict: [set: update_on_conflict],
	returning: true,
	conflict_target: [:user_id, :conversation_id]
	)
	end

	def read_cng(struct, params) do
	struct
	\|> cast(params, [:read])
	\|> validate_required([:read])
	end

	def mark_as_read(%User{} = user, %Conversation{} = conversation) do
	with %__MODULE__{} = participation <- for_user_and_conversation(user, conversation) do
	mark_as_read(participation)
	end
	end

	def mark_as_read(participation) do
	__MODULE__
	\|> where(id: ^participation.id)
	\|> update(set: [read: true])
	\|> select([p], p)
	\|> Repo.update_all([])
	\|> case do
	{1, [participation]} ->
	participation = Repo.preload(participation, :user)
	User.set_unread_conversation_count(participation.user)
	{:ok, participation}

	error ->
	error
	end
	end

	def mark_all_as_read(%User{local: true} = user, %User{} = target_user) do
	target_conversation_ids =
	__MODULE__
	\|> where([p], p.user_id == ^target_user.id)
	\|> select([p], p.conversation_id)
	\|> Repo.all()

	__MODULE__
	\|> where([p], p.user_id == ^user.id)
	\|> where([p], p.conversation_id in ^target_conversation_ids)
	\|> update([p], set: [read: true])
	\|> Repo.update_all([])

	{:ok, user} = User.set_unread_conversation_count(user)
	{:ok, user, []}
	end

	def mark_all_as_read(%User{} = user, %User{}), do: {:ok, user, []}

	def mark_all_as_read(%User{} = user) do
	{_, participations} =
	__MODULE__
	\|> where([p], p.user_id == ^user.id)
	\|> where([p], not p.read)
	\|> update([p], set: [read: true])
	\|> select([p], p)
	\|> Repo.update_all([])

	{:ok, user} = User.set_unread_conversation_count(user)
	{:ok, user, participations}
	end

	def mark_as_unread(participation) do
	participation
	\|> read_cng(%{read: false})
	\|> Repo.update()
	end

	def for_user(user, params \\ %{}) do
	from(p in __MODULE__,
	where: p.user_id == ^user.id,
	order_by: [desc: p.updated_at],
	preload: [conversation: [:users]]
	)
	\|> restrict_recipients(user, params)
	\|> Pleroma.Pagination.fetch_paginated(params)
	end

	def restrict_recipients(query, user, %{recipients: user_ids}) do
	user_binary_ids =
	[user.id \| user_ids]
	\|> Enum.uniq()
	\|> User.binary_id()

	conversation_subquery =
	__MODULE__
	\|> group_by([p], p.conversation_id)
	\|> having(
	[p],
	count(p.user_id) == ^length(user_binary_ids) and
	fragment("array_agg(?) @> ?", p.user_id, ^user_binary_ids)
	)
	\|> select([p], %{id: p.conversation_id})

	query
	\|> join(:inner, [p], c in subquery(conversation_subquery), on: p.conversation_id == c.id)
	end

	def restrict_recipients(query, _, _), do: query

	def for_user_and_conversation(user, conversation) do
	from(p in __MODULE__,
	where: p.user_id == ^user.id,
	where: p.conversation_id == ^conversation.id
	)
	\|> Repo.one()
	end

	def for_user_with_last_activity_id(user, params \\ %{}) do
	for_user(user, params)
	\|> Enum.map(fn participation ->
	activity_id =
	- ActivityPub.fetch_latest_activity_id_for_context(participation.conversation.ap_id, %{
	- user: user,
	- blocking_user: user
	- })
	+ ActivityPub.fetch_latest_direct_activity_id_for_context(
	+ participation.conversation.ap_id,
	+ %{
	+ user: user,
	+ blocking_user: user
	+ }
	+ )

	%{
	participation
	\| last_activity_id: activity_id
	}
	end)
	\|> Enum.reject(&is_nil(&1.last_activity_id))
	end

	def get(_, _ \\ [])
	def get(nil, _), do: nil

	def get(id, params) do
	query =
	if preload = params[:preload] do
	from(p in __MODULE__,
	preload: ^preload
	)
	else
	__MODULE__
	end

	Repo.get(query, id)
	end

	def set_recipients(participation, user_ids) do
	user_ids =
	[participation.user_id \| user_ids]
	\|> Enum.uniq()

	Repo.transaction(fn ->
	query =
	from(r in RecipientShip,
	where: r.participation_id == ^participation.id
	)

	Repo.delete_all(query)

	users =
	from(u in User,
	where: u.id in ^user_ids
	)
	\|> Repo.all()

	RecipientShip.create(users, participation)
	:ok
	end)

	{:ok, Repo.preload(participation, :recipients, force: true)}
	end

	def unread_conversation_count_for_user(user) do
	from(p in __MODULE__,
	where: p.user_id == ^user.id,
	where: not p.read,
	select: %{count: count(p.id)}
	)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/types/date_time.ex b/lib/pleroma/ecto_type/activity_pub/object_validators/date_time.ex
	similarity index 77%
	rename from lib/pleroma/web/activity_pub/object_validators/types/date_time.ex
	rename to lib/pleroma/ecto_type/activity_pub/object_validators/date_time.ex
	index 4f412fcde..d852c0abd 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/types/date_time.ex
	+++ b/lib/pleroma/ecto_type/activity_pub/object_validators/date_time.ex
	@@ -1,34 +1,38 @@
	-defmodule Pleroma.Web.ActivityPub.ObjectValidators.Types.DateTime do
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime do
	@moduledoc """
	The AP standard defines the date fields in AP as xsd:DateTime. Elixir's
	DateTime can't parse this, but it can parse the related iso8601. This
	module punches the date until it looks like iso8601 and normalizes to
	it.

	DateTimes without a timezone offset are treated as UTC.

	Reference: https://www.w3.org/TR/activitystreams-vocabulary/#dfn-published
	"""
	use Ecto.Type

	def type, do: :string

	def cast(datetime) when is_binary(datetime) do
	with {:ok, datetime, _} <- DateTime.from_iso8601(datetime) do
	{:ok, DateTime.to_iso8601(datetime)}
	else
	{:error, :missing_offset} -> cast("#{datetime}Z")
	_e -> :error
	end
	end

	def cast(_), do: :error

	def dump(data) do
	{:ok, data}
	end

	def load(data) do
	{:ok, data}
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/types/object_id.ex b/lib/pleroma/ecto_type/activity_pub/object_validators/object_id.ex
	similarity index 69%
	rename from lib/pleroma/web/activity_pub/object_validators/types/object_id.ex
	rename to lib/pleroma/ecto_type/activity_pub/object_validators/object_id.ex
	index f71f76370..8034235b0 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/types/object_id.ex
	+++ b/lib/pleroma/ecto_type/activity_pub/object_validators/object_id.ex
	@@ -1,23 +1,27 @@
	-defmodule Pleroma.Web.ActivityPub.ObjectValidators.Types.ObjectID do
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.ObjectID do
	use Ecto.Type

	def type, do: :string

	def cast(object) when is_binary(object) do
	# Host has to be present and scheme has to be an http scheme (for now)
	case URI.parse(object) do
	%URI{host: nil} -> :error
	%URI{host: ""} -> :error
	%URI{scheme: scheme} when scheme in ["https", "http"] -> {:ok, object}
	_ -> :error
	end
	end

	def cast(%{"id" => object}), do: cast(object)

	def cast(_), do: :error

	def dump(data), do: {:ok, data}

	def load(data), do: {:ok, data}
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/types/recipients.ex b/lib/pleroma/ecto_type/activity_pub/object_validators/recipients.ex
	similarity index 64%
	rename from lib/pleroma/web/activity_pub/object_validators/types/recipients.ex
	rename to lib/pleroma/ecto_type/activity_pub/object_validators/recipients.ex
	index 408e0f6ee..205527a96 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/types/recipients.ex
	+++ b/lib/pleroma/ecto_type/activity_pub/object_validators/recipients.ex
	@@ -1,36 +1,40 @@
	-defmodule Pleroma.Web.ActivityPub.ObjectValidators.Types.Recipients do
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.Recipients do
	use Ecto.Type

	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types.ObjectID
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators.ObjectID

	def type, do: {:array, ObjectID}

	def cast(object) when is_binary(object) do
	cast([object])
	end

	def cast(data) when is_list(data) do
	data
	\|> Enum.reduce_while({:ok, []}, fn element, {:ok, list} ->
	case ObjectID.cast(element) do
	{:ok, id} ->
	{:cont, {:ok, [id \| list]}}

	_ ->
	{:halt, :error}
	end
	end)
	end

	def cast(_) do
	:error
	end

	def dump(data) do
	{:ok, data}
	end

	def load(data) do
	{:ok, data}
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/types/safe_text.ex b/lib/pleroma/ecto_type/activity_pub/object_validators/safe_text.ex
	similarity index 85%
	rename from lib/pleroma/web/activity_pub/object_validators/types/safe_text.ex
	rename to lib/pleroma/ecto_type/activity_pub/object_validators/safe_text.ex
	index 95c948123..7f0405c7b 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/types/safe_text.ex
	+++ b/lib/pleroma/ecto_type/activity_pub/object_validators/safe_text.ex
	@@ -1,25 +1,25 @@
	# 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.ObjectValidators.Types.SafeText do
	+defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.SafeText do
	use Ecto.Type

	alias Pleroma.HTML

	def type, do: :string

	def cast(str) when is_binary(str) do
	{:ok, HTML.filter_tags(str)}
	end

	def cast(_), do: :error

	def dump(data) do
	{:ok, data}
	end

	def load(data) do
	{:ok, data}
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/types/uri.ex b/lib/pleroma/ecto_type/activity_pub/object_validators/uri.ex
	similarity index 63%
	rename from lib/pleroma/web/activity_pub/object_validators/types/uri.ex
	rename to lib/pleroma/ecto_type/activity_pub/object_validators/uri.ex
	index 24845bcc0..2054c26be 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/types/uri.ex
	+++ b/lib/pleroma/ecto_type/activity_pub/object_validators/uri.ex
	@@ -1,20 +1,24 @@
	-defmodule Pleroma.Web.ActivityPub.ObjectValidators.Types.Uri do
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.EctoType.ActivityPub.ObjectValidators.Uri do
	use Ecto.Type

	def type, do: :string

	def cast(uri) when is_binary(uri) do
	case URI.parse(uri) do
	%URI{host: nil} -> :error
	%URI{host: ""} -> :error
	%URI{scheme: scheme} when scheme in ["https", "http"] -> {:ok, uri}
	_ -> :error
	end
	end

	def cast(_), do: :error

	def dump(data), do: {:ok, data}

	def load(data), do: {:ok, data}
	end
	diff --git a/lib/pleroma/ecto_type/config/atom.ex b/lib/pleroma/ecto_type/config/atom.ex
	new file mode 100644
	index 000000000..df565d432
	--- /dev/null
	+++ b/lib/pleroma/ecto_type/config/atom.ex
	@@ -0,0 +1,26 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.EctoType.Config.Atom do
	+ use Ecto.Type
	+
	+ def type, do: :atom
	+
	+ def cast(key) when is_atom(key) do
	+ {:ok, key}
	+ end
	+
	+ def cast(key) when is_binary(key) do
	+ {:ok, Pleroma.ConfigDB.string_to_elixir_types(key)}
	+ end
	+
	+ def cast(_), do: :error
	+
	+ def load(key) do
	+ {:ok, Pleroma.ConfigDB.string_to_elixir_types(key)}
	+ end
	+
	+ def dump(key) when is_atom(key), do: {:ok, inspect(key)}
	+ def dump(_), do: :error
	+end
	diff --git a/lib/pleroma/ecto_type/config/binary_value.ex b/lib/pleroma/ecto_type/config/binary_value.ex
	new file mode 100644
	index 000000000..bbd2608c5
	--- /dev/null
	+++ b/lib/pleroma/ecto_type/config/binary_value.ex
	@@ -0,0 +1,27 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.EctoType.Config.BinaryValue do
	+ use Ecto.Type
	+
	+ def type, do: :term
	+
	+ def cast(value) when is_binary(value) do
	+ if String.valid?(value) do
	+ {:ok, value}
	+ else
	+ {:ok, :erlang.binary_to_term(value)}
	+ end
	+ end
	+
	+ def cast(value), do: {:ok, value}
	+
	+ def load(value) when is_binary(value) do
	+ {:ok, :erlang.binary_to_term(value)}
	+ end
	+
	+ def dump(value) do
	+ {:ok, :erlang.term_to_binary(value)}
	+ end
	+end
	diff --git a/lib/pleroma/migration_helper/notification_backfill.ex b/lib/pleroma/migration_helper/notification_backfill.ex
	index 09647d12a..b3770307a 100644
	--- a/lib/pleroma/migration_helper/notification_backfill.ex
	+++ b/lib/pleroma/migration_helper/notification_backfill.ex
	@@ -1,85 +1,85 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.MigrationHelper.NotificationBackfill do
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User

	import Ecto.Query

	def fill_in_notification_types do
	query =
	from(n in Pleroma.Notification,
	where: is_nil(n.type),
	preload: :activity
	)

	query
	- \|> Repo.all()
	+ \|> Repo.chunk_stream(100)
	\|> Enum.each(fn notification ->
	type =
	notification.activity
	\|> type_from_activity()

	notification
	\|> Notification.changeset(%{type: type})
	\|> Repo.update()
	end)
	end

	# This is copied over from Notifications to keep this stable.
	defp type_from_activity(%{data: %{"type" => type}} = activity) do
	case type do
	"Follow" ->
	accepted_function = fn activity ->
	with %User{} = follower <- User.get_by_ap_id(activity.data["actor"]),
	%User{} = followed <- User.get_by_ap_id(activity.data["object"]) do
	Pleroma.FollowingRelationship.following?(follower, followed)
	end
	end

	if accepted_function.(activity) do
	"follow"
	else
	"follow_request"
	end

	"Announce" ->
	"reblog"

	"Like" ->
	"favourite"

	"Move" ->
	"move"

	"EmojiReact" ->
	"pleroma:emoji_reaction"

	# Compatibility with old reactions
	"EmojiReaction" ->
	"pleroma:emoji_reaction"

	"Create" ->
	activity
	\|> type_from_activity_object()

	t ->
	raise "No notification type for activity type #{t}"
	end
	end

	defp type_from_activity_object(%{data: %{"type" => "Create", "object" => %{}}}), do: "mention"

	defp type_from_activity_object(%{data: %{"type" => "Create"}} = activity) do
	object = Object.get_by_ap_id(activity.data["object"])

	case object && object.data["type"] do
	"ChatMessage" -> "pleroma:chat_mention"
	_ -> "mention"
	end
	end
	end
	diff --git a/lib/pleroma/repo.ex b/lib/pleroma/repo.ex
	index f62138466..6d85d70bc 100644
	--- a/lib/pleroma/repo.ex
	+++ b/lib/pleroma/repo.ex
	@@ -1,85 +1,113 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Repo do
	use Ecto.Repo,
	otp_app: :pleroma,
	adapter: Ecto.Adapters.Postgres,
	migration_timestamps: [type: :naive_datetime_usec]

	+ import Ecto.Query
	require Logger

	defmodule Instrumenter do
	use Prometheus.EctoInstrumenter
	end

	@doc """
	Dynamically loads the repository url from the
	DATABASE_URL environment variable.
	"""
	def init(_, opts) do
	{:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))}
	end

	@doc "find resource based on prepared query"
	@spec find_resource(Ecto.Query.t()) :: {:ok, struct()} \| {:error, :not_found}
	def find_resource(%Ecto.Query{} = query) do
	case __MODULE__.one(query) do
	nil -> {:error, :not_found}
	resource -> {:ok, resource}
	end
	end

	def find_resource(_query), do: {:error, :not_found}

	@doc """
	Gets association from cache or loads if need

	## Examples

	iex> Repo.get_assoc(token, :user)
	%User{}

	"""
	@spec get_assoc(struct(), atom()) :: {:ok, struct()} \| {:error, :not_found}
	def get_assoc(resource, association) do
	case __MODULE__.preload(resource, association) do
	%{^association => assoc} when not is_nil(assoc) -> {:ok, assoc}
	_ -> {:error, :not_found}
	end
	end

	def check_migrations_applied!() do
	unless Pleroma.Config.get(
	[:i_am_aware_this_may_cause_data_loss, :disable_migration_check],
	false
	) do
	Ecto.Migrator.with_repo(__MODULE__, 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"
	)

	raise Pleroma.Repo.UnappliedMigrationsError
	end
	end)
	else
	:ok
	end
	end
	+
	+ def chunk_stream(query, chunk_size) do
	+ # We don't actually need start and end funcitons of resource streaming,
	+ # but it seems to be the only way to not fetch records one-by-one and
	+ # have individual records be the elements of the stream, instead of
	+ # lists of records
	+ Stream.resource(
	+ fn -> 0 end,
	+ fn
	+ last_id ->
	+ query
	+ \|> order_by(asc: :id)
	+ \|> where([r], r.id > ^last_id)
	+ \|> limit(^chunk_size)
	+ \|> all()
	+ \|> case do
	+ [] ->
	+ {:halt, last_id}
	+
	+ records ->
	+ last_id = List.last(records).id
	+ {records, last_id}
	+ end
	+ end,
	+ fn _ -> :ok end
	+ )
	+ end
	end

	defmodule Pleroma.Repo.UnappliedMigrationsError do
	defexception message: "Unapplied Migrations detected"
	end
	diff --git a/lib/pleroma/signature.ex b/lib/pleroma/signature.ex
	index d01728361..3aa6909d2 100644
	--- a/lib/pleroma/signature.ex
	+++ b/lib/pleroma/signature.ex
	@@ -1,74 +1,74 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Signature do
	@behaviour HTTPSignatures.Adapter

	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Keys
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types

	def key_id_to_actor_id(key_id) do
	uri =
	URI.parse(key_id)
	\|> Map.put(:fragment, nil)

	uri =
	if not is_nil(uri.path) and String.ends_with?(uri.path, "/publickey") do
	Map.put(uri, :path, String.replace(uri.path, "/publickey", ""))
	else
	uri
	end

	maybe_ap_id = URI.to_string(uri)

	- case Types.ObjectID.cast(maybe_ap_id) do
	+ case ObjectValidators.ObjectID.cast(maybe_ap_id) do
	{:ok, ap_id} ->
	{:ok, ap_id}

	_ ->
	case Pleroma.Web.WebFinger.finger(maybe_ap_id) do
	%{"ap_id" => ap_id} -> {:ok, ap_id}
	_ -> {:error, maybe_ap_id}
	end
	end
	end

	def fetch_public_key(conn) do
	with %{"keyId" => kid} <- HTTPSignatures.signature_for_conn(conn),
	{:ok, actor_id} <- key_id_to_actor_id(kid),
	{:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
	{:ok, public_key}
	else
	e ->
	{:error, e}
	end
	end

	def refetch_public_key(conn) do
	with %{"keyId" => kid} <- HTTPSignatures.signature_for_conn(conn),
	{:ok, actor_id} <- key_id_to_actor_id(kid),
	{:ok, _user} <- ActivityPub.make_user_from_ap_id(actor_id),
	{:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
	{:ok, public_key}
	else
	e ->
	{:error, e}
	end
	end

	def sign(%User{} = user, headers) do
	with {:ok, %{keys: keys}} <- User.ensure_keys_present(user),
	{:ok, private_key, _} <- Keys.keys_from_pem(keys) do
	HTTPSignatures.sign(private_key, user.ap_id <> "#main-key", headers)
	end
	end

	def signed_date, do: signed_date(NaiveDateTime.utc_now())

	def signed_date(%NaiveDateTime{} = date) do
	Timex.format!(date, "{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} GMT")
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 52ac9052b..19ce9fb56 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2236 +1,2247 @@
	# 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.RepoStreamer
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	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
	@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)
	+ 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)
	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(: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(:settings, :map, default: nil)
	- field(:uri, Types.Uri, 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)

	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

	@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{confirmation_pending: true}) do
	case Config.get([:instance, :account_activation_required]) do
	true -> :confirmation_pending
	_ -> :active
	end
	end

	def account_status(%User{}), do: :active

	@spec visible_for?(User.t(), User.t() \| nil) :: boolean()
	def visible_for?(user, for_user \\ nil)

	def visible_for?(%User{invisible: true}, _), do: false

	def visible_for?(%User{id: user_id}, %User{id: user_id}), do: true

	def visible_for?(%User{local: local} = user, nil) do
	cfg_key =
	if local,
	do: :local,
	else: :remote

	if Config.get([:restrict_unauthenticated, :profiles, cfg_key]),
	do: false,
	else: account_status(user) == :active
	end

	def visible_for?(%User{} = user, for_user) do
	account_status(user) == :active \|\| superuser?(for_user)
	end

	def visible_for?(_, _), do: false

	@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

	defdelegate following_count(user), to: FollowingRelationship

	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 = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.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
	]
	)
	\|> 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 = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.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
	]
	)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> 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
	bio = get_change(changeset, :bio)
	name = get_change(changeset, :name)

	if bio \|\| name do
	emoji = Map.merge(Emoji.Formatter.get_emoji_map(bio), Emoji.Formatter.get_emoji_map(name))
	put_change(changeset, :emoji, emoji)
	else
	changeset
	end
	end

	defp put_change_if_present(changeset, map_field, value_function) do
	if value = get_change(changeset, map_field) do
	with {:ok, new_value} <- value_function.(value) do
	put_change(changeset, map_field, new_value)
	else
	_ -> changeset
	end
	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)

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	need_confirmation? =
	if is_nil(opts[:need_confirmation]) do
	Pleroma.Config.get([:instance, :account_activation_required])
	else
	opts[:need_confirmation]
	end

	struct
	\|> confirmation_changeset(need_confirmation: need_confirmation?)
	- \|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation, :emoji])
	+ \|> cast(params, [
	+ :bio,
	+ :raw_bio,
	+ :email,
	+ :name,
	+ :nickname,
	+ :password,
	+ :password_confirmation,
	+ :emoji
	+ ])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_format(:email, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_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 Pleroma.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 = Pleroma.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, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
	{:ok, _} <- try_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def try_send_confirmation_email(%User{} = user) do
	if user.confirmation_pending &&
	Pleroma.Config.get([:instance, :account_activation_required]) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def try_send_confirmation_email(users) do
	Enum.each(users, &try_send_confirmation_email/1)
	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

	defdelegate following(user), to: FollowingRelationship

	def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
	deny_follow_blocked = Pleroma.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()
	\|> set_cache()
	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()
	\|> set_cache()

	{:ok, follower, followed}

	nil ->
	{:error, "Not subscribed!"}
	end
	end

	defdelegate following?(follower, followed), to: FollowingRelationship

	@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 = Pleroma.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, 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), do: get_followers_query(user, nil)

	@spec get_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_followers(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, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> User.Query.build(%{external: true})
	\|> Repo.all()
	end

	def get_followers_ids(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, 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), do: get_friends_query(user, nil)

	def get_friends(user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

	def get_friends_ap_ids(user) do
	user
	\|> get_friends_query(nil)
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end

	def get_friends_ids(user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	defdelegate get_follow_requests(user), to: FollowingRelationship

	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

	def update_follower_count(%User{} = user) do
	if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
	follower_count_query =
	User.Query.build(%{followers: user, deactivated: false})
	\|> select([u], %{count: count(u.id)})

	User
	\|> where(id: ^user.id)
	\|> join(:inner, [u], s in subquery(follower_count_query))
	\|> update([u, s],
	set: [follower_count: s.count]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	else
	{:ok, maybe_fetch_follow_information(user)}
	end
	end

	@spec update_following_count(User.t()) :: User.t()
	def update_following_count(%User{local: false} = user) do
	if Pleroma.Config.get([:instance, :external_user_synchronization]) do
	maybe_fetch_follow_information(user)
	else
	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})
	\|> Repo.update!()
	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 = Pleroma.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)

	if 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 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

	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)

	if status == :confirmation_pending do
	delete_and_invalidate_cache(user)
	else
	user
	\|> change(%{deactivated: true, email: nil})
	\|> 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 perform(atom(), User.t(), list()) :: list() \| {:error, any()}
	def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
	when is_list(blocked_identifiers) do
	Enum.map(
	blocked_identifiers,
	fn blocked_identifier ->
	with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
	{:ok, _user_block} <- block(blocker, blocked),
	{:ok, _} <- ActivityPub.block(blocker, blocked) do
	blocked
	else
	err ->
	Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
	err
	end
	end
	)
	end

	def perform(:follow_import, %User{} = follower, followed_identifiers)
	when is_list(followed_identifiers) do
	Enum.map(
	followed_identifiers,
	fn followed_identifier ->
	with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
	{:ok, follower} <- maybe_direct_follow(follower, followed),
	{:ok, _} <- ActivityPub.follow(follower, followed) do
	followed
	else
	err ->
	Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
	err
	end
	end
	)
	end

	@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 blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
	BackgroundWorker.enqueue("blocks_import", %{
	"blocker_id" => blocker.id,
	"blocked_identifiers" => blocked_identifiers
	})
	end

	def follow_import(%User{} = follower, followed_identifiers)
	when is_list(followed_identifiers) do
	BackgroundWorker.enqueue("follow_import", %{
	"follower_id" => follower.id,
	"followed_identifiers" => followed_identifiers
	})
	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()
	\|> RepoStreamer.chunk_stream(50)
	\|> 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: Pleroma.Config.get([:markup, :scrub_policy])

	def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)

	def get_or_fetch_by_ap_id(ap_id) do
	cached_user = get_cached_by_ap_id(ap_id)

	maybe_fetched_user = needs_update?(cached_user) && fetch_by_ap_id(ap_id)

	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) do
	with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
	{: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 Pleroma.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

	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 = Pleroma.Config.get([:assets, :mascots])
	default_mascot = Pleroma.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

	defdelegate search(query, opts \\ []), to: User.Search

	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 = Pleroma.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 = Pleroma.Config.get([:instance, :account_field_name_length], 255)
	value_limit = Pleroma.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, Pleroma.Config.get([:instance, :account_field_name_length], 255))

	{value, _chopped} =
	String.split_at(value, Pleroma.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(%{settings: settings}, [:settings])
	\|> validate_required([: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

	def add_pinnned_activity(user, %Pleroma.Activity{id: id}) do
	if id not in user.pinned_activities do
	max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
	params = %{pinned_activities: user.pinned_activities ++ [id]}

	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}) do
	params = %{pinned_activities: List.delete(user.pinned_activities, id)}

	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/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index c9dc6135c..3e4f3ad30 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1466 +1,1467 @@
	# 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.ActivityExpiration
	alias Pleroma.Config
	alias Pleroma.Constants
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	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

	defp 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

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

	defp increase_poll_votes_if_vote(_create_data), do: :noop

	@object_types ["ChatMessage"]
	@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"]
	}) do
	{:ok, activity, meta}
	end
	end

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

	# 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}

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

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

	error ->
	{:error, error}
	end
	end

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

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

	defp maybe_create_activity_expiration({:ok, %{data: %{"expires_at" => expires_at}} = activity}) do
	with {:ok, _} <- ActivityExpiration.create(activity, expires_at) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(result), do: result

	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_activity_id_for_context(conversation.ap_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),
	_ <- increase_poll_votes_if_vote(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

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

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

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

	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 accept(map()) :: {:ok, Activity.t()} \| {:error, any()}
	def accept(params) do
	accept_or_reject("Accept", params)
	end

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

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

	data =
	%{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
	\|> Maps.put_if_present("id", activity_id)

	with {:ok, activity} <- insert(data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

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

	data =
	%{
	"to" => to,
	"cc" => cc,
	"type" => "Update",
	"actor" => actor,
	"object" => object
	}
	\|> Maps.put_if_present("id", activity_id)

	with {:ok, activity} <- insert(data, local),
	_ <- notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

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

	defp do_follow(follower, followed, activity_id, local, opts) do
	skip_notify_and_stream = Keyword.get(opts, :skip_notify_and_stream, false)
	data = make_follow_data(follower, followed, activity_id)

	with {:ok, activity} <- insert(data, local),
	_ <- skip_notify_and_stream \|\| notify_and_stream(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

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

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

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

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

	if unfollow_blocked and fetch_latest_follow(blocker, blocked) do
	unfollow(blocker, blocked, nil, local)
	end

	block_data = make_block_data(blocker, blocked, activity_id)

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

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

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

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

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

	{:ok, activity}
	end
	end

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

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

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

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

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

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

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

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

	- @spec fetch_latest_activity_id_for_context(String.t(), keyword() \| map()) ::
	+ @spec fetch_latest_direct_activity_id_for_context(String.t(), keyword() \| map()) ::
	FlakeId.Ecto.CompatType.t() \| nil
	- def fetch_latest_activity_id_for_context(context, opts \\ %{}) do
	+ 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("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,
	reply_visibility: "self"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'inReplyTo' is null OR ? = ANY(?)",
	object.data,
	^user.ap_id,
	activity.recipients
	)
	)
	end

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

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{exclude_reblogs: 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 (? && ?)", activity.recipients, ^blocked_ap_ids),
	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 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_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)
	\|> 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
	data = Transmogrifier.maybe_fix_user_object(data)
	discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

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

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

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

	# nickname can be nil because of virtual actors
	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),
	{:ok, hide_follows} <- collection_private(following_data),
	{:ok, followers_data} <-
	Fetcher.fetch_and_contain_remote_object_from_id(user.follower_address),
	{:ok, hide_followers} <- collection_private(followers_data) do
	{:ok,
	%{
	hide_follows: hide_follows,
	follower_count: normalize_counter(followers_data["totalItems"]),
	following_count: normalize_counter(following_data["totalItems"]),
	hide_followers: hide_followers
	}}
	else
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

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

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

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

	{:collections_available, false} ->
	user_data

	{:enabled, false} ->
	user_data

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

	user_data
	end
	end

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

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

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

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

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data) 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, e} ->
	Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}
	end
	end

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

	if user && !User.ap_enabled?(user) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	if user do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	else
	data
	\|> User.remote_user_changeset()
	\|> Repo.insert()
	\|> User.set_cache()
	end
	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/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index c01c5f780..6a83a2c33 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,133 +1,133 @@
	# 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.ObjectValidator do
	@moduledoc """
	This module is responsible for validating an object (which can be an activity)
	and checking if it is both well formed and also compatible with our view of
	the system.
	"""

	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator

	@spec validate(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	def validate(object, meta)

	def validate(%{"type" => "Undo"} = object, meta) do
	with {:ok, object} <-
	object
	\|> UndoValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Delete"} = object, meta) do
	with cng <- DeleteValidator.cast_and_validate(object),
	do_not_federate <- DeleteValidator.do_not_federate?(cng),
	{:ok, object} <- Ecto.Changeset.apply_action(cng, :insert) do
	object = stringify_keys(object)
	meta = Keyword.put(meta, :do_not_federate, do_not_federate)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Like"} = object, meta) do
	with {:ok, object} <-
	object
	\|> LikeValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "ChatMessage"} = object, meta) do
	with {:ok, object} <-
	object
	\|> ChatMessageValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "EmojiReact"} = object, meta) do
	with {:ok, object} <-
	object
	\|> EmojiReactValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object \|> Map.from_struct())
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Create", "object" => object} = create_activity, meta) do
	with {:ok, object_data} <- cast_and_apply(object),
	meta = Keyword.put(meta, :object_data, object_data \|> stringify_keys),
	{:ok, create_activity} <-
	create_activity
	\|> CreateChatMessageValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(%{"type" => "Announce"} = object, meta) do
	with {:ok, object} <-
	object
	\|> AnnounceValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object \|> Map.from_struct())
	{:ok, object, meta}
	end
	end

	def cast_and_apply(%{"type" => "ChatMessage"} = object) do
	ChatMessageValidator.cast_and_apply(object)
	end

	def cast_and_apply(o), do: {:error, {:validator_not_set, o}}

	def stringify_keys(%{__struct__: _} = object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) when is_map(object) do
	object
	\|> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
	end

	def stringify_keys(object) when is_list(object) do
	object
	\|> Enum.map(&stringify_keys/1)
	end

	def stringify_keys(object), do: object

	def fetch_actor(object) do
	- with {:ok, actor} <- Types.ObjectID.cast(object["actor"]) do
	+ with {:ok, actor} <- ObjectValidators.ObjectID.cast(object["actor"]) do
	User.get_or_fetch_by_ap_id(actor)
	end
	end

	def fetch_actor_and_object(object) do
	fetch_actor(object)
	Object.normalize(object["object"], true)
	:ok
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex b/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	index 40f861f47..6f757f49c 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	@@ -1,101 +1,101 @@
	# 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.ObjectValidators.AnnounceValidator do
	use Ecto.Schema

	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	require Pleroma.Constants

	@primary_key false

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:type, :string)
	- field(:object, Types.ObjectID)
	- field(:actor, Types.ObjectID)
	+ field(:object, ObjectValidators.ObjectID)
	+ field(:actor, ObjectValidators.ObjectID)
	field(:context, :string, autogenerate: {Utils, :generate_context_id, []})
	- field(:to, Types.Recipients, default: [])
	- field(:cc, Types.Recipients, default: [])
	- field(:published, Types.DateTime)
	+ field(:to, ObjectValidators.Recipients, default: [])
	+ field(:cc, ObjectValidators.Recipients, default: [])
	+ field(:published, ObjectValidators.DateTime)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	\|> fix_after_cast()
	end

	def fix_after_cast(cng) do
	cng
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Announce"])
	\|> validate_required([:id, :type, :object, :actor, :to, :cc])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_existing_announce()
	\|> validate_announcable()
	end

	def validate_announcable(cng) do
	with actor when is_binary(actor) <- get_field(cng, :actor),
	object when is_binary(object) <- get_field(cng, :object),
	%User{} = actor <- User.get_cached_by_ap_id(actor),
	%Object{} = object <- Object.get_cached_by_ap_id(object),
	false <- Visibility.is_public?(object) do
	same_actor = object.data["actor"] == actor.ap_id
	is_public = Pleroma.Constants.as_public() in (get_field(cng, :to) ++ get_field(cng, :cc))

	cond do
	same_actor && is_public ->
	cng
	\|> add_error(:actor, "can not announce this object publicly")

	!same_actor ->
	cng
	\|> add_error(:actor, "can not announce this object")

	true ->
	cng
	end
	else
	_ -> cng
	end
	end

	def validate_existing_announce(cng) do
	actor = get_field(cng, :actor)
	object = get_field(cng, :object)

	if actor && object && Utils.get_existing_announce(actor, %{data: %{"id" => object}}) do
	cng
	\|> add_error(:actor, "already announced this object")
	\|> add_error(:object, "already announced by this actor")
	else
	cng
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex b/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	index 138736f23..c481d79e0 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/chat_message_validator.ex
	@@ -1,123 +1,123 @@
	# 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.ObjectValidators.ChatMessageValidator do
	use Ecto.Schema

	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.Transmogrifier, only: [fix_emoji: 1]

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	- field(:to, Types.Recipients, default: [])
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	+ field(:to, ObjectValidators.Recipients, default: [])
	field(:type, :string)
	- field(:content, Types.SafeText)
	- field(:actor, Types.ObjectID)
	- field(:published, Types.DateTime)
	+ field(:content, ObjectValidators.SafeText)
	+ field(:actor, ObjectValidators.ObjectID)
	+ field(:published, ObjectValidators.DateTime)
	field(:emoji, :map, default: %{})

	embeds_one(:attachment, AttachmentValidator)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def fix(data) do
	data
	\|> fix_emoji()
	\|> fix_attachment()
	\|> Map.put_new("actor", data["attributedTo"])
	end

	# Throws everything but the first one away
	def fix_attachment(%{"attachment" => [attachment \| _]} = data) do
	data
	\|> Map.put("attachment", attachment)
	end

	def fix_attachment(data), do: data

	def changeset(struct, data) do
	data = fix(data)

	struct
	\|> cast(data, List.delete(__schema__(:fields), :attachment))
	\|> cast_embed(:attachment)
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["ChatMessage"])
	\|> validate_required([:id, :actor, :to, :type, :published])
	\|> validate_content_or_attachment()
	\|> validate_length(:to, is: 1)
	\|> validate_length(:content, max: Pleroma.Config.get([:instance, :remote_limit]))
	\|> validate_local_concern()
	end

	def validate_content_or_attachment(cng) do
	attachment = get_field(cng, :attachment)

	if attachment do
	cng
	else
	cng
	\|> validate_required([:content])
	end
	end

	@doc """
	Validates the following
	- If both users are in our system
	- If at least one of the users in this ChatMessage is a local user
	- If the recipient is not blocking the actor
	"""
	def validate_local_concern(cng) do
	with actor_ap <- get_field(cng, :actor),
	{_, %User{} = actor} <- {:find_actor, User.get_cached_by_ap_id(actor_ap)},
	{_, %User{} = recipient} <-
	{:find_recipient, User.get_cached_by_ap_id(get_field(cng, :to) \|> hd())},
	{_, false} <- {:blocking_actor?, User.blocks?(recipient, actor)},
	{_, true} <- {:local?, Enum.any?([actor, recipient], & &1.local)} do
	cng
	else
	{:blocking_actor?, true} ->
	cng
	\|> add_error(:actor, "actor is blocked by recipient")

	{:local?, false} ->
	cng
	\|> add_error(:actor, "actor and recipient are both remote")

	{:find_actor, _} ->
	cng
	\|> add_error(:actor, "can't find user")

	{:find_recipient, _} ->
	cng
	\|> add_error(:to, "can't find user")
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/create_chat_message_validator.ex b/lib/pleroma/web/activity_pub/object_validators/create_chat_message_validator.ex
	index fc582400b..7269f9ff0 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/create_chat_message_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/create_chat_message_validator.ex
	@@ -1,91 +1,91 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	# NOTES
	# - Can probably be a generic create validator
	# - doesn't embed, will only get the object id
	defmodule Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator do
	use Ecto.Schema
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators

	alias Pleroma.Object
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	- field(:actor, Types.ObjectID)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	+ field(:actor, ObjectValidators.ObjectID)
	field(:type, :string)
	- field(:to, Types.Recipients, default: [])
	- field(:object, Types.ObjectID)
	+ field(:to, ObjectValidators.Recipients, default: [])
	+ field(:object, ObjectValidators.ObjectID)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_data(data) do
	cast(%__MODULE__{}, data, __schema__(:fields))
	end

	def cast_and_validate(data, meta \\ []) do
	cast_data(data)
	\|> validate_data(meta)
	end

	def validate_data(cng, meta \\ []) do
	cng
	\|> validate_required([:id, :actor, :to, :type, :object])
	\|> validate_inclusion(:type, ["Create"])
	\|> validate_actor_presence()
	\|> validate_recipients_match(meta)
	\|> validate_actors_match(meta)
	\|> validate_object_nonexistence()
	end

	def validate_object_nonexistence(cng) do
	cng
	\|> validate_change(:object, fn :object, object_id ->
	if Object.get_cached_by_ap_id(object_id) do
	[{:object, "The object to create already exists"}]
	else
	[]
	end
	end)
	end

	def validate_actors_match(cng, meta) do
	object_actor = meta[:object_data]["actor"]

	cng
	\|> validate_change(:actor, fn :actor, actor ->
	if actor == object_actor do
	[]
	else
	[{:actor, "Actor doesn't match with object actor"}]
	end
	end)
	end

	def validate_recipients_match(cng, meta) do
	object_recipients = meta[:object_data]["to"] \|\| []

	cng
	\|> validate_change(:to, fn :to, recipients ->
	activity_set = MapSet.new(recipients)
	object_set = MapSet.new(object_recipients)

	if MapSet.equal?(activity_set, object_set) do
	[]
	else
	[{:to, "Recipients don't match with object recipients"}]
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/create_note_validator.ex b/lib/pleroma/web/activity_pub/object_validators/create_note_validator.ex
	index 926804ce7..316bd0c07 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/create_note_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/create_note_validator.ex
	@@ -1,30 +1,30 @@
	# 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.ObjectValidators.CreateNoteValidator do
	use Ecto.Schema

	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.NoteValidator
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types

	import Ecto.Changeset

	@primary_key false

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	- field(:actor, Types.ObjectID)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	+ field(:actor, ObjectValidators.ObjectID)
	field(:type, :string)
	field(:to, {:array, :string})
	field(:cc, {:array, :string})
	field(:bto, {:array, :string}, default: [])
	field(:bcc, {:array, :string}, default: [])

	embeds_one(:object, NoteValidator)
	end

	def cast_data(data) do
	cast(%__MODULE__{}, data, __schema__(:fields))
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/delete_validator.ex b/lib/pleroma/web/activity_pub/object_validators/delete_validator.ex
	index e5d08eb5c..93a7b0e0b 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/delete_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/delete_validator.ex
	@@ -1,101 +1,101 @@
	# 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.ObjectValidators.DeleteValidator do
	use Ecto.Schema

	alias Pleroma.Activity
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.User
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:type, :string)
	- field(:actor, Types.ObjectID)
	- field(:to, Types.Recipients, default: [])
	- field(:cc, Types.Recipients, default: [])
	- field(:deleted_activity_id, Types.ObjectID)
	- field(:object, Types.ObjectID)
	+ field(:actor, ObjectValidators.ObjectID)
	+ field(:to, ObjectValidators.Recipients, default: [])
	+ field(:cc, ObjectValidators.Recipients, default: [])
	+ field(:deleted_activity_id, ObjectValidators.ObjectID)
	+ field(:object, ObjectValidators.ObjectID)
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	def add_deleted_activity_id(cng) do
	object =
	cng
	\|> get_field(:object)

	with %Activity{id: id} <- Activity.get_create_by_object_ap_id(object) do
	cng
	\|> put_change(:deleted_activity_id, id)
	else
	_ -> cng
	end
	end

	@deletable_types ~w{
	Answer
	Article
	Audio
	ChatMessage
	Event
	Note
	Page
	Question
	Tombstone
	Video
	}
	def validate_data(cng) do
	cng
	\|> validate_required([:id, :type, :actor, :to, :cc, :object])
	\|> validate_inclusion(:type, ["Delete"])
	\|> validate_actor_presence()
	\|> validate_deletion_rights()
	\|> validate_object_or_user_presence(allowed_types: @deletable_types)
	\|> add_deleted_activity_id()
	end

	def do_not_federate?(cng) do
	!same_domain?(cng)
	end

	defp same_domain?(cng) do
	actor_uri =
	cng
	\|> get_field(:actor)
	\|> URI.parse()

	object_uri =
	cng
	\|> get_field(:object)
	\|> URI.parse()

	object_uri.host == actor_uri.host
	end

	def validate_deletion_rights(cng) do
	actor = User.get_cached_by_ap_id(get_field(cng, :actor))

	if User.superuser?(actor) \|\| same_domain?(cng) do
	cng
	else
	cng
	\|> add_error(:actor, "is not allowed to delete object")
	end
	end

	def cast_and_validate(data) do
	data
	\|> cast_data
	\|> validate_data
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex b/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	index e87519c59..a543af1f8 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	@@ -1,81 +1,81 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator do
	use Ecto.Schema

	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:type, :string)
	- field(:object, Types.ObjectID)
	- field(:actor, Types.ObjectID)
	+ field(:object, ObjectValidators.ObjectID)
	+ field(:actor, ObjectValidators.ObjectID)
	field(:context, :string)
	field(:content, :string)
	field(:to, {:array, :string}, default: [])
	field(:cc, {:array, :string}, default: [])
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	\|> fix_after_cast()
	end

	def fix_after_cast(cng) do
	cng
	\|> fix_context()
	end

	def fix_context(cng) do
	object = get_field(cng, :object)

	with nil <- get_field(cng, :context),
	%Object{data: %{"context" => context}} <- Object.get_cached_by_ap_id(object) do
	cng
	\|> put_change(:context, context)
	else
	_ ->
	cng
	end
	end

	def validate_emoji(cng) do
	content = get_field(cng, :content)

	if Pleroma.Emoji.is_unicode_emoji?(content) do
	cng
	else
	cng
	\|> add_error(:content, "must be a single character emoji")
	end
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["EmojiReact"])
	\|> validate_required([:id, :type, :object, :actor, :context, :to, :cc, :content])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_emoji()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/like_validator.ex b/lib/pleroma/web/activity_pub/object_validators/like_validator.ex
	index 034f25492..493e4c247 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/like_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/like_validator.ex
	@@ -1,99 +1,99 @@
	# 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.ObjectValidators.LikeValidator do
	use Ecto.Schema

	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	alias Pleroma.Web.ActivityPub.Utils

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:type, :string)
	- field(:object, Types.ObjectID)
	- field(:actor, Types.ObjectID)
	+ field(:object, ObjectValidators.ObjectID)
	+ field(:actor, ObjectValidators.ObjectID)
	field(:context, :string)
	- field(:to, Types.Recipients, default: [])
	- field(:cc, Types.Recipients, default: [])
	+ field(:to, ObjectValidators.Recipients, default: [])
	+ field(:cc, ObjectValidators.Recipients, default: [])
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	\|> fix_after_cast()
	end

	def fix_after_cast(cng) do
	cng
	\|> fix_recipients()
	\|> fix_context()
	end

	def fix_context(cng) do
	object = get_field(cng, :object)

	with nil <- get_field(cng, :context),
	%Object{data: %{"context" => context}} <- Object.get_cached_by_ap_id(object) do
	cng
	\|> put_change(:context, context)
	else
	_ ->
	cng
	end
	end

	def fix_recipients(cng) do
	to = get_field(cng, :to)
	cc = get_field(cng, :cc)
	object = get_field(cng, :object)

	with {[], []} <- {to, cc},
	%Object{data: %{"actor" => actor}} <- Object.get_cached_by_ap_id(object),
	- {:ok, actor} <- Types.ObjectID.cast(actor) do
	+ {:ok, actor} <- ObjectValidators.ObjectID.cast(actor) do
	cng
	\|> put_change(:to, [actor])
	else
	_ ->
	cng
	end
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Like"])
	\|> validate_required([:id, :type, :object, :actor, :context, :to, :cc])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_existing_like()
	end

	def validate_existing_like(%{changes: %{actor: actor, object: object}} = cng) do
	if Utils.get_existing_like(actor, %{data: %{"id" => object}}) do
	cng
	\|> add_error(:actor, "already liked this object")
	\|> add_error(:object, "already liked by this actor")
	else
	cng
	end
	end

	def validate_existing_like(cng), do: cng
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/note_validator.ex b/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	index 462a5620a..a10728ac6 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/note_validator.ex
	@@ -1,64 +1,64 @@
	# 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.ObjectValidators.NoteValidator do
	use Ecto.Schema

	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators

	import Ecto.Changeset

	@primary_key false

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:to, {:array, :string}, default: [])
	field(:cc, {:array, :string}, default: [])
	field(:bto, {:array, :string}, default: [])
	field(:bcc, {:array, :string}, default: [])
	# TODO: Write type
	field(:tag, {:array, :map}, default: [])
	field(:type, :string)
	field(:content, :string)
	field(:context, :string)
	- field(:actor, Types.ObjectID)
	- field(:attributedTo, Types.ObjectID)
	+ field(:actor, ObjectValidators.ObjectID)
	+ field(:attributedTo, ObjectValidators.ObjectID)
	field(:summary, :string)
	- field(:published, Types.DateTime)
	+ field(:published, ObjectValidators.DateTime)
	# TODO: Write type
	field(:emoji, :map, default: %{})
	field(:sensitive, :boolean, default: false)
	# TODO: Write type
	field(:attachment, {:array, :map}, default: [])
	field(:replies_count, :integer, default: 0)
	field(:like_count, :integer, default: 0)
	field(:announcement_count, :integer, default: 0)
	field(:inRepyTo, :string)
	- field(:uri, Types.Uri)
	+ field(:uri, ObjectValidators.Uri)

	field(:likes, {:array, :string}, default: [])
	field(:announcements, {:array, :string}, default: [])

	# see if needed
	field(:conversation, :string)
	field(:context_id, :string)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Note"])
	\|> validate_required([:id, :actor, :to, :cc, :type, :content, :context])
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/undo_validator.ex b/lib/pleroma/web/activity_pub/object_validators/undo_validator.ex
	index d0ba418e8..e8d2d39c1 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/undo_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/undo_validator.ex
	@@ -1,62 +1,62 @@
	# 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.ObjectValidators.UndoValidator do
	use Ecto.Schema

	alias Pleroma.Activity
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, Types.ObjectID, primary_key: true)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:type, :string)
	- field(:object, Types.ObjectID)
	- field(:actor, Types.ObjectID)
	+ field(:object, ObjectValidators.ObjectID)
	+ field(:actor, ObjectValidators.ObjectID)
	field(:to, {:array, :string}, default: [])
	field(:cc, {:array, :string}, default: [])
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	end

	def validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Undo"])
	\|> validate_required([:id, :type, :object, :actor, :to, :cc])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_undo_rights()
	end

	def validate_undo_rights(cng) do
	actor = get_field(cng, :actor)
	object = get_field(cng, :object)

	with %Activity{data: %{"actor" => object_actor}} <- Activity.get_by_ap_id(object),
	true <- object_actor != actor do
	cng
	\|> add_error(:actor, "not the same as object actor")
	else
	_ -> cng
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/url_object_validator.ex b/lib/pleroma/web/activity_pub/object_validators/url_object_validator.ex
	index 47e231150..f64fac46d 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/url_object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/url_object_validator.ex
	@@ -1,20 +1,24 @@
	+# 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.ObjectValidators.UrlObjectValidator do
	use Ecto.Schema

	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators

	import Ecto.Changeset
	@primary_key false

	embedded_schema do
	field(:type, :string)
	- field(:href, Types.Uri)
	+ field(:href, ObjectValidators.Uri)
	field(:mediaType, :string)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	\|> validate_required([:type, :href, :mediaType])
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 985921aa0..851f474b8 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1206 +1,1206 @@
	# 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.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.Activity
	alias Pleroma.EarmarkRenderer
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.FollowingRelationship
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator
	alias Pleroma.Workers.TransmogrifierWorker

	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object, options \\ []) do
	object
	\|> strip_internal_fields
	\|> fix_actor
	\|> fix_url
	\|> fix_attachments
	\|> fix_context
	\|> fix_in_reply_to(options)
	\|> fix_emoji
	\|> fix_tag
	\|> fix_content_map
	\|> fix_addressing
	\|> fix_summary
	\|> fix_type(options)
	\|> fix_content
	end

	def fix_summary(%{"summary" => nil} = object) do
	Map.put(object, "summary", "")
	end

	def fix_summary(%{"summary" => _} = object) do
	# summary is present, nothing to do
	object
	end

	def fix_summary(object), do: Map.put(object, "summary", "")

	def fix_addressing_list(map, field) do
	cond do
	is_binary(map[field]) ->
	Map.put(map, field, [map[field]])

	is_nil(map[field]) ->
	Map.put(map, field, [])

	true ->
	map
	end
	end

	def fix_explicit_addressing(
	%{"to" => to, "cc" => cc} = object,
	explicit_mentions,
	follower_collection
	) do
	explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)

	explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)

	final_cc =
	(cc ++ explicit_cc)
	\|> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
	\|> Enum.uniq()

	object
	\|> Map.put("to", explicit_to)
	\|> Map.put("cc", final_cc)
	end

	def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object

	# if directMessage flag is set to true, leave the addressing alone
	def fix_explicit_addressing(%{"directMessage" => true} = object), do: object

	def fix_explicit_addressing(object) do
	explicit_mentions = Utils.determine_explicit_mentions(object)

	%User{follower_address: follower_collection} =
	object
	\|> Containment.get_actor()
	\|> User.get_cached_by_ap_id()

	explicit_mentions =
	explicit_mentions ++
	[
	Pleroma.Constants.as_public(),
	follower_collection
	]

	fix_explicit_addressing(object, explicit_mentions, follower_collection)
	end

	# if as:Public is addressed, then make sure the followers collection is also addressed
	# so that the activities will be delivered to local users.
	def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
	recipients = to ++ cc

	if followers_collection not in recipients do
	cond do
	Pleroma.Constants.as_public() in cc ->
	to = to ++ [followers_collection]
	Map.put(object, "to", to)

	Pleroma.Constants.as_public() in to ->
	cc = cc ++ [followers_collection]
	Map.put(object, "cc", cc)

	true ->
	object
	end
	else
	object
	end
	end

	def fix_implicit_addressing(object, _), do: object

	def fix_addressing(object) do
	{:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
	followers_collection = User.ap_followers(user)

	object
	\|> fix_addressing_list("to")
	\|> fix_addressing_list("cc")
	\|> fix_addressing_list("bto")
	\|> fix_addressing_list("bcc")
	\|> fix_explicit_addressing()
	\|> fix_implicit_addressing(followers_collection)
	end

	def fix_actor(%{"attributedTo" => actor} = object) do
	Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
	end

	def fix_in_reply_to(object, options \\ [])

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
	when not is_nil(in_reply_to) do
	in_reply_to_id = prepare_in_reply_to(in_reply_to)
	object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
	depth = (options[:depth] \|\| 0) + 1

	if Federator.allowed_thread_distance?(depth) do
	with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
	%Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] \|\| in_reply_to_id)
	\|> Map.put("conversation", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])
	else
	e ->
	Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
	object
	end
	else
	object
	end
	end

	def fix_in_reply_to(object, _options), do: object

	defp prepare_in_reply_to(in_reply_to) do
	cond do
	is_bitstring(in_reply_to) ->
	in_reply_to

	is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
	in_reply_to["id"]

	is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
	Enum.at(in_reply_to, 0)

	true ->
	""
	end
	end

	def fix_context(object) do
	context = object["context"] \|\| object["conversation"] \|\| Utils.generate_context_id()

	object
	\|> Map.put("context", context)
	\|> Map.put("conversation", context)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	attachments =
	Enum.map(attachment, fn data ->
	url =
	cond do
	is_list(data["url"]) -> List.first(data["url"])
	is_map(data["url"]) -> data["url"]
	true -> nil
	end

	media_type =
	cond do
	is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
	MIME.valid?(data["mediaType"]) -> data["mediaType"]
	MIME.valid?(data["mimeType"]) -> data["mimeType"]
	true -> nil
	end

	href =
	cond do
	is_map(url) && is_binary(url["href"]) -> url["href"]
	is_binary(data["url"]) -> data["url"]
	is_binary(data["href"]) -> data["href"]
	end

	attachment_url =
	%{"href" => href}
	\|> Maps.put_if_present("mediaType", media_type)
	\|> Maps.put_if_present("type", Map.get(url \|\| %{}, "type"))

	%{"url" => [attachment_url]}
	\|> Maps.put_if_present("mediaType", media_type)
	\|> Maps.put_if_present("type", data["type"])
	\|> Maps.put_if_present("name", data["name"])
	end)

	Map.put(object, "attachment", attachments)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
	object
	\|> Map.put("attachment", [attachment])
	\|> fix_attachments()
	end

	def fix_attachments(object), do: object

	def fix_url(%{"url" => url} = object) when is_map(url) do
	Map.put(object, "url", url["href"])
	end

	def fix_url(%{"type" => object_type, "url" => url} = object)
	when object_type in ["Video", "Audio"] and is_list(url) do
	first_element = Enum.at(url, 0)

	link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)

	object
	\|> Map.put("attachment", [first_element])
	\|> Map.put("url", link_element["href"])
	end

	def fix_url(%{"type" => object_type, "url" => url} = object)
	when object_type != "Video" and is_list(url) do
	first_element = Enum.at(url, 0)

	url_string =
	cond do
	is_bitstring(first_element) -> first_element
	is_map(first_element) -> first_element["href"] \|\| ""
	true -> ""
	end

	Map.put(object, "url", url_string)
	end

	def fix_url(object), do: object

	def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
	emoji =
	tags
	\|> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

	Map.put(mapping, name, data["icon"]["url"])
	end)

	# we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
	emoji = Map.merge(object["emoji"] \|\| %{}, emoji)

	Map.put(object, "emoji", emoji)
	end

	def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
	name = String.trim(tag["name"], ":")
	emoji = %{name => tag["icon"]["url"]}

	Map.put(object, "emoji", emoji)
	end

	def fix_emoji(object), do: object

	def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
	tags =
	tag
	\|> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
	\|> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)

	Map.put(object, "tag", tag ++ tags)
	end

	def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
	combined = [tag, String.slice(hashtag, 1..-1)]

	Map.put(object, "tag", combined)
	end

	def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])

	def fix_tag(object), do: object

	# content map usually only has one language so this will do for now.
	def fix_content_map(%{"contentMap" => content_map} = object) do
	content_groups = Map.to_list(content_map)
	{_, content} = Enum.at(content_groups, 0)

	Map.put(object, "content", content)
	end

	def fix_content_map(object), do: object

	def fix_type(object, options \\ [])

	def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
	when is_binary(reply_id) do
	with true <- Federator.allowed_thread_distance?(options[:depth]),
	{:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
	Map.put(object, "type", "Answer")
	else
	_ -> object
	end
	end

	def fix_type(object, _), do: object

	defp fix_content(%{"mediaType" => "text/markdown", "content" => content} = object)
	when is_binary(content) do
	html_content =
	content
	\|> Earmark.as_html!(%Earmark.Options{renderer: EarmarkRenderer})
	\|> Pleroma.HTML.filter_tags()

	Map.merge(object, %{"content" => html_content, "mediaType" => "text/html"})
	end

	defp fix_content(object), do: object

	defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
	with true <- id =~ "follows",
	%User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
	%Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
	{:ok, activity}
	else
	_ -> {:error, nil}
	end
	end

	defp mastodon_follow_hack(_, _), do: {:error, nil}

	defp get_follow_activity(follow_object, followed) do
	with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
	{_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
	{:ok, activity}
	else
	# Can't find the activity. This might a Mastodon 2.3 "Accept"
	{:activity, nil} ->
	mastodon_follow_hack(follow_object, followed)

	_ ->
	{:error, nil}
	end
	end

	# Reduce the object list to find the reported user.
	defp get_reported(objects) do
	Enum.reduce_while(objects, nil, fn ap_id, _ ->
	with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
	{:halt, user}
	else
	_ -> {:cont, nil}
	end
	end)
	end

	def handle_incoming(data, options \\ [])

	# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
	# with nil ID.
	def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
	with context <- data["context"] \|\| Utils.generate_context_id(),
	content <- data["content"] \|\| "",
	%User{} = actor <- User.get_cached_by_ap_id(actor),
	# Reduce the object list to find the reported user.
	%User{} = account <- get_reported(objects),
	# Remove the reported user from the object list.
	statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
	%{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content,
	additional: %{"cc" => [account.ap_id]}
	}
	\|> ActivityPub.flag()
	end
	end

	# disallow objects with bogus IDs
	def handle_incoming(%{"id" => nil}, _options), do: :error
	def handle_incoming(%{"id" => ""}, _options), do: :error
	# length of https:// = 8, should validate better, but good enough for now.
	def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
	do: :error

	# TODO: validate those with a Ecto scheme
	# - tags
	# - emoji
	def handle_incoming(
	%{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
	options
	)
	when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
	actor = Containment.get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with nil <- Activity.get_create_by_object_ap_id(object["id"]),
	{:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
	object = fix_object(object, options)

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: object["conversation"],
	local: false,
	published: data["published"],
	additional:
	Map.take(data, [
	"cc",
	"directMessage",
	"id"
	])
	}

	with {:ok, created_activity} <- ActivityPub.create(params) do
	reply_depth = (options[:depth] \|\| 0) + 1

	if Federator.allowed_thread_distance?(reply_depth) do
	for reply_id <- replies(object) do
	Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
	"id" => reply_id,
	"depth" => reply_depth
	})
	end
	end

	{:ok, created_activity}
	end
	else
	%Activity{} = activity -> {:ok, activity}
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
	options
	) do
	actor = Containment.get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
	reply_depth = (options[:depth] \|\| 0) + 1
	options = Keyword.put(options, :depth, reply_depth)
	object = fix_object(object, options)

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: nil,
	local: false,
	published: data["published"],
	additional: Map.take(data, ["cc", "id"])
	}

	ActivityPub.listen(params)
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
	_options
	) do
	with %User{local: true} = followed <-
	User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
	{:ok, %User{} = follower} <-
	User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
	{:ok, activity} <-
	ActivityPub.follow(follower, followed, id, false, skip_notify_and_stream: true) do
	with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
	{_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
	{_, false} <- {:user_locked, User.locked?(followed)},
	{_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
	{_, {:ok, _}} <-
	{:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
	{:ok, _relationship} <-
	FollowingRelationship.update(follower, followed, :follow_accept) do
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: data,
	local: true
	})
	else
	{:user_blocked, true} ->
	{:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
	{:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)

	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: data,
	local: true
	})

	{:follow, {:error, _}} ->
	{:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
	{:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)

	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: data,
	local: true
	})

	{:user_locked, true} ->
	{:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_pending)
	:noop
	end

	ActivityPub.notify_and_stream(activity)
	{:ok, activity}
	else
	_e ->
	:error
	end
	end

	def handle_incoming(
	%{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
	User.update_follower_count(followed)
	User.update_following_count(follower)

	Notification.update_notification_type(followed, follow_activity)

	ActivityPub.accept(%{
	to: follow_activity.data["to"],
	type: "Accept",
	actor: followed,
	object: follow_activity.data["id"],
	local: false,
	activity_id: id
	})
	else
	_e ->
	:error
	end
	end

	def handle_incoming(
	%{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
	_options
	) do
	with actor <- Containment.get_actor(data),
	{:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
	{:ok, activity} <-
	ActivityPub.reject(%{
	to: follow_activity.data["to"],
	type: "Reject",
	actor: followed,
	object: follow_activity.data["id"],
	local: false,
	activity_id: id
	}) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	@misskey_reactions %{
	"like" => "👍",
	"love" => "❤️",
	"laugh" => "😆",
	"hmm" => "🤔",
	"surprise" => "😮",
	"congrats" => "🎉",
	"angry" => "💢",
	"confused" => "😥",
	"rip" => "😇",
	"pudding" => "🍮",
	"star" => "⭐"
	}

	@doc "Rewrite misskey likes into EmojiReacts"
	def handle_incoming(
	%{
	"type" => "Like",
	"_misskey_reaction" => reaction
	} = data,
	options
	) do
	data
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", @misskey_reactions[reaction] \|\| reaction)
	\|> handle_incoming(options)
	end

	def handle_incoming(
	%{"type" => "Create", "object" => %{"type" => "ChatMessage"}} = data,
	_options
	) do
	with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
	{:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	def handle_incoming(%{"type" => type} = data, _options)
	when type in ["Like", "EmojiReact", "Announce"] do
	with :ok <- ObjectValidator.fetch_actor_and_object(data),
	{:ok, activity, _meta} <-
	Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	e -> {:error, e}
	end
	end

	def handle_incoming(
	%{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
	data,
	_options
	)
	when object_type in [
	"Person",
	"Application",
	"Service",
	"Organization"
	] do
	with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
	{:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)

	actor
	\|> User.remote_user_changeset(new_user_data)
	\|> User.update_and_set_cache()

	ActivityPub.update(%{
	local: false,
	to: data["to"] \|\| [],
	cc: data["cc"] \|\| [],
	object: object,
	actor: actor_id,
	activity_id: data["id"]
	})
	else
	e ->
	Logger.error(e)
	:error
	end
	end

	def handle_incoming(
	%{"type" => "Delete"} = data,
	_options
	) do
	with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	else
	{:error, {:validate_object, _}} = e ->
	# Check if we have a create activity for this
	- with {:ok, object_id} <- Types.ObjectID.cast(data["object"]),
	+ with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
	%Activity{data: %{"actor" => actor}} <-
	Activity.create_by_object_ap_id(object_id) \|> Repo.one(),
	# We have one, insert a tombstone and retry
	{:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	handle_incoming(data)
	else
	_ -> e
	end
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "object" => followed},
	"actor" => follower,
	"id" => id
	} = _data,
	_options
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	{:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
	User.unfollow(follower, followed)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => type}
	} = data,
	_options
	)
	when type in ["Like", "EmojiReact", "Announce", "Block"] do
	with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
	{:ok, activity}
	end
	end

	# For Undos that don't have the complete object attached, try to find it in our database.
	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => object
	} = activity,
	options
	)
	when is_binary(object) do
	with %Activity{data: data} <- Activity.get_by_ap_id(object) do
	activity
	\|> Map.put("object", data)
	\|> handle_incoming(options)
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
	_options
	) do
	with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
	{:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
	{:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
	User.unfollow(blocker, blocked)
	User.block(blocker, blocked)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Move",
	"actor" => origin_actor,
	"object" => origin_actor,
	"target" => target_actor
	},
	_options
	) do
	with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
	{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
	true <- origin_actor in target_user.also_known_as do
	ActivityPub.move(origin_user, target_user, false)
	else
	_e -> :error
	end
	end

	def handle_incoming(_, _), do: :error

	@spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} \| nil
	def get_obj_helper(id, options \\ []) do
	case Object.normalize(id, true, options) do
	%Object{} = object -> {:ok, object}
	_ -> nil
	end
	end

	@spec get_embedded_obj_helper(String.t() \| Object.t(), User.t()) :: {:ok, Object.t()} \| nil
	def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
	ap_id: ap_id
	})
	when attributed_to == ap_id do
	with {:ok, activity} <-
	handle_incoming(%{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => attributed_to,
	"object" => data
	}) do
	{:ok, Object.normalize(activity)}
	else
	_ -> get_obj_helper(object_id)
	end
	end

	def get_embedded_obj_helper(object_id, _) do
	get_obj_helper(object_id)
	end

	def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
	with false <- String.starts_with?(in_reply_to, "http"),
	{:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
	Map.put(object, "inReplyTo", replied_to_object["external_url"] \|\| in_reply_to)
	else
	_e -> object
	end
	end

	def set_reply_to_uri(obj), do: obj

	@doc """
	Serialized Mastodon-compatible `replies` collection containing _self-replies_.
	Based on Mastodon's ActivityPub::NoteSerializer#replies.
	"""
	def set_replies(obj_data) do
	replies_uris =
	with limit when limit > 0 <-
	Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
	%Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
	object
	\|> Object.self_replies()
	\|> select([o], fragment("?->>'id'", o.data))
	\|> limit(^limit)
	\|> Repo.all()
	else
	_ -> []
	end

	set_replies(obj_data, replies_uris)
	end

	defp set_replies(obj, []) do
	obj
	end

	defp set_replies(obj, replies_uris) do
	replies_collection = %{
	"type" => "Collection",
	"items" => replies_uris
	}

	Map.merge(obj, %{"replies" => replies_collection})
	end

	def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
	items
	end

	def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
	items
	end

	def replies(_), do: []

	# Prepares the object of an outgoing create activity.
	def prepare_object(object) do
	object
	\|> set_sensitive
	\|> add_hashtags
	\|> add_mention_tags
	\|> add_emoji_tags
	\|> add_attributed_to
	\|> prepare_attachments
	\|> set_conversation
	\|> set_reply_to_uri
	\|> set_replies
	\|> strip_internal_fields
	\|> strip_internal_tags
	\|> set_type
	end

	# @doc
	# """
	# internal -> Mastodon
	# """

	def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
	when activity_type in ["Create", "Listen"] do
	object =
	object_id
	\|> Object.normalize()
	\|> Map.get(:data)
	\|> prepare_object

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
	object =
	object_id
	\|> Object.normalize()

	data =
	if Visibility.is_private?(object) && object.data["actor"] == ap_id do
	data \|> Map.put("object", object \|> Map.get(:data) \|> prepare_object)
	else
	data \|> maybe_fix_object_url
	end

	data =
	data
	\|> strip_internal_fields
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.delete("bcc")

	{:ok, data}
	end

	# Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
	# because of course it does.
	def prepare_outgoing(%{"type" => "Accept"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => "Reject"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => _type} = data) do
	data =
	data
	\|> strip_internal_fields
	\|> maybe_fix_object_url
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end

	def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
	with false <- String.starts_with?(object, "http"),
	{:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
	%{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
	relative_object do
	Map.put(data, "object", external_url)
	else
	{:fetch, e} ->
	Logger.error("Couldn't fetch #{object} #{inspect(e)}")
	data

	_ ->
	data
	end
	end

	def maybe_fix_object_url(data), do: data

	def add_hashtags(object) do
	tags =
	(object["tag"] \|\| [])
	\|> Enum.map(fn
	# Expand internal representation tags into AS2 tags.
	tag when is_binary(tag) ->
	%{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
	"name" => "##{tag}",
	"type" => "Hashtag"
	}

	# Do not process tags which are already AS2 tag objects.
	tag when is_map(tag) ->
	tag
	end)

	Map.put(object, "tag", tags)
	end

	# TODO These should be added on our side on insertion, it doesn't make much
	# sense to regenerate these all the time
	def add_mention_tags(object) do
	to = object["to"] \|\| []
	cc = object["cc"] \|\| []
	mentioned = User.get_users_from_set(to ++ cc, local_only: false)

	mentions = Enum.map(mentioned, &build_mention_tag/1)

	tags = object["tag"] \|\| []
	Map.put(object, "tag", tags ++ mentions)
	end

	defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
	%{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
	end

	def take_emoji_tags(%User{emoji: emoji}) do
	emoji
	\|> Map.to_list()
	\|> Enum.map(&build_emoji_tag/1)
	end

	# TODO: we should probably send mtime instead of unix epoch time for updated
	def add_emoji_tags(%{"emoji" => emoji} = object) do
	tags = object["tag"] \|\| []

	out = Enum.map(emoji, &build_emoji_tag/1)

	Map.put(object, "tag", tags ++ out)
	end

	def add_emoji_tags(object), do: object

	defp build_emoji_tag({name, url}) do
	%{
	"icon" => %{"url" => url, "type" => "Image"},
	"name" => ":" <> name <> ":",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z",
	"id" => url
	}
	end

	def set_conversation(object) do
	Map.put(object, "conversation", object["context"])
	end

	def set_sensitive(%{"sensitive" => true} = object) do
	object
	end

	def set_sensitive(object) do
	tags = object["tag"] \|\| []
	Map.put(object, "sensitive", "nsfw" in tags)
	end

	def set_type(%{"type" => "Answer"} = object) do
	Map.put(object, "type", "Note")
	end

	def set_type(object), do: object

	def add_attributed_to(object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]
	Map.put(object, "attributedTo", attributed_to)
	end

	# TODO: Revisit this
	def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object

	def prepare_attachments(object) do
	attachments =
	object
	\|> Map.get("attachment", [])
	\|> Enum.map(fn data ->
	[%{"mediaType" => media_type, "href" => href} \| _] = data["url"]

	%{
	"url" => href,
	"mediaType" => media_type,
	"name" => data["name"],
	"type" => "Document"
	}
	end)

	Map.put(object, "attachment", attachments)
	end

	def strip_internal_fields(object) do
	Map.drop(object, Pleroma.Constants.object_internal_fields())
	end

	defp strip_internal_tags(%{"tag" => tags} = object) do
	tags = Enum.filter(tags, fn x -> is_map(x) end)

	Map.put(object, "tag", tags)
	end

	defp strip_internal_tags(object), do: object

	def perform(:user_upgrade, user) do
	# we pass a fake user so that the followers collection is stripped away
	old_follower_address = User.ap_followers(%User{nickname: user.nickname})

	from(
	a in Activity,
	where: ^old_follower_address in a.recipients,
	update: [
	set: [
	recipients:
	fragment(
	"array_replace(?,?,?)",
	a.recipients,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)
	\|> Repo.update_all([])
	end

	def upgrade_user_from_ap_id(ap_id) do
	with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
	{:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
	{:ok, user} <- update_user(user, data) do
	TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
	{:ok, user}
	else
	%User{} = user -> {:ok, user}
	e -> e
	end
	end

	defp update_user(user, data) do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	end

	def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
	Map.put(data, "url", url["href"])
	end

	def maybe_fix_user_url(data), do: data

	def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
	end
	diff --git a/lib/pleroma/web/admin_api/controllers/config_controller.ex b/lib/pleroma/web/admin_api/controllers/config_controller.ex
	index d6e2019bc..7f60470cb 100644
	--- a/lib/pleroma/web/admin_api/controllers/config_controller.ex
	+++ b/lib/pleroma/web/admin_api/controllers/config_controller.ex
	@@ -1,152 +1,152 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Config
	alias Pleroma.ConfigDB
	alias Pleroma.Plugs.OAuthScopesPlug

	@descriptions Pleroma.Docs.JSON.compile()

	plug(Pleroma.Web.ApiSpec.CastAndValidate)
	plug(OAuthScopesPlug, %{scopes: ["write"], admin: true} when action == :update)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read"], admin: true}
	when action in [:show, :descriptions]
	)

	action_fallback(Pleroma.Web.AdminAPI.FallbackController)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.Admin.ConfigOperation

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

	json(conn, descriptions)
	end

	def show(conn, %{only_db: true}) do
	with :ok <- configurable_from_database() do
	configs = Pleroma.Repo.all(ConfigDB)
	- render(conn, "index.json", %{configs: configs})
	+
	+ render(conn, "index.json", %{
	+ configs: configs,
	+ need_reboot: Restarter.Pleroma.need_reboot?()
	+ })
	end
	end

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

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

	db_value = configs[group][key]

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

	- %{
	- group: ConfigDB.convert(group),
	- key: ConfigDB.convert(key),
	- value: ConfigDB.convert(merged_value)
	+ %ConfigDB{
	+ group: group,
	+ key: key,
	+ value: merged_value
	}
	\|> Pleroma.Maps.put_if_present(:db, db)
	end)
	end)
	\|> List.flatten()

	- json(conn, %{configs: merged, need_reboot: Restarter.Pleroma.need_reboot?()})
	+ render(conn, "index.json", %{
	+ configs: merged,
	+ need_reboot: Restarter.Pleroma.need_reboot?()
	+ })
	end
	end

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

	%{group: group, key: key, value: value} ->
	ConfigDB.update_or_create(%{group: group, key: key, value: value})
	end)
	\|> Enum.reject(fn {result, _} -> result == :error end)

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

	Config.TransferTask.load_and_update_env(deleted, false)

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

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

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

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

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

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

	defp whitelisted_config?(%{group: group, key: key}) do
	whitelisted_config?(group, key)
	end

	defp whitelisted_config?(%{group: group} = config) do
	whitelisted_config?(group, config[:key])
	end
	end
	diff --git a/lib/pleroma/web/admin_api/views/config_view.ex b/lib/pleroma/web/admin_api/views/config_view.ex
	index 587ef760e..d2d8b5907 100644
	--- a/lib/pleroma/web/admin_api/views/config_view.ex
	+++ b/lib/pleroma/web/admin_api/views/config_view.ex
	@@ -1,33 +1,30 @@
	# 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.ConfigView do
	use Pleroma.Web, :view

	+ alias Pleroma.ConfigDB
	+
	def render("index.json", %{configs: configs} = params) do
	- map = %{
	- configs: render_many(configs, __MODULE__, "show.json", as: :config)
	+ %{
	+ configs: render_many(configs, __MODULE__, "show.json", as: :config),
	+ need_reboot: params[:need_reboot]
	}
	-
	- if params[:need_reboot] do
	- Map.put(map, :need_reboot, true)
	- else
	- map
	- end
	end

	def render("show.json", %{config: config}) do
	map = %{
	- key: config.key,
	- group: config.group,
	- value: Pleroma.ConfigDB.from_binary_with_convert(config.value)
	+ key: ConfigDB.to_json_types(config.key),
	+ group: ConfigDB.to_json_types(config.group),
	+ value: ConfigDB.to_json_types(config.value)
	}

	if config.db != [] do
	Map.put(map, :db, config.db)
	else
	map
	end
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/notification_operation.ex b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	index c966b553a..41328b5f2 100644
	--- a/lib/pleroma/web/api_spec/operations/notification_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	@@ -1,212 +1,211 @@
	# 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.NotificationOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	alias Pleroma.Web.ApiSpec.Schemas.Status
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	import Pleroma.Web.ApiSpec.Helpers

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

	def index_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Get all notifications",
	description:
	"Notifications concerning the user. This API returns Link headers containing links to the next/previous page. However, the links can also be constructed dynamically using query params and `id` values.",
	operationId: "NotificationController.index",
	security: [%{"oAuth" => ["read:notifications"]}],
	parameters:
	[
	Operation.parameter(
	:exclude_types,
	:query,
	%Schema{type: :array, items: notification_type()},
	"Array of types to exclude"
	),
	Operation.parameter(
	:account_id,
	:query,
	%Schema{type: :string},
	"Return only notifications received from this account"
	),
	Operation.parameter(
	:exclude_visibilities,
	:query,
	%Schema{type: :array, items: VisibilityScope},
	"Exclude the notifications for activities with the given visibilities"
	),
	Operation.parameter(
	:include_types,
	:query,
	%Schema{type: :array, items: notification_type()},
	"Include the notifications for activities with the given types"
	),
	Operation.parameter(
	:with_muted,
	:query,
	BooleanLike,
	"Include the notifications from muted users"
	)
	] ++ pagination_params(),
	responses: %{
	200 =>
	Operation.response("Array of notifications", "application/json", %Schema{
	type: :array,
	items: notification()
	}),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Get a single notification",
	description: "View information about a notification with a given ID.",
	operationId: "NotificationController.show",
	security: [%{"oAuth" => ["read:notifications"]}],
	parameters: [id_param()],
	responses: %{
	200 => Operation.response("Notification", "application/json", notification())
	}
	}
	end

	def clear_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss all notifications",
	description: "Clear all notifications from the server.",
	operationId: "NotificationController.clear",
	security: [%{"oAuth" => ["write:notifications"]}],
	responses: %{200 => empty_object_response()}
	}
	end

	def dismiss_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss a single notification",
	description: "Clear a single notification from the server.",
	operationId: "NotificationController.dismiss",
	parameters: [id_param()],
	security: [%{"oAuth" => ["write:notifications"]}],
	responses: %{200 => empty_object_response()}
	}
	end

	def dismiss_via_body_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss a single notification",
	deprecated: true,
	description: "Clear a single notification from the server.",
	operationId: "NotificationController.dismiss_via_body",
	requestBody:
	request_body(
	"Parameters",
	%Schema{type: :object, properties: %{id: %Schema{type: :string}}},
	required: true
	),
	security: [%{"oAuth" => ["write:notifications"]}],
	responses: %{200 => empty_object_response()}
	}
	end

	def destroy_multiple_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss multiple notifications",
	operationId: "NotificationController.destroy_multiple",
	security: [%{"oAuth" => ["write:notifications"]}],
	parameters: [
	Operation.parameter(
	:ids,
	:query,
	%Schema{type: :array, items: %Schema{type: :string}},
	"Array of notification IDs to dismiss",
	required: true
	)
	],
	responses: %{200 => empty_object_response()}
	}
	end

	def notification do
	%Schema{
	title: "Notification",
	description: "Response schema for a notification",
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	type: notification_type(),
	created_at: %Schema{type: :string, format: :"date-time"},
	account: %Schema{
	allOf: [Account],
	description: "The account that performed the action that generated the notification."
	},
	status: %Schema{
	allOf: [Status],
	description:
	"Status that was the object of the notification, e.g. in mentions, reblogs, favourites, or polls.",
	nullable: true
	}
	},
	example: %{
	"id" => "34975861",
	"type" => "mention",
	"created_at" => "2019-11-23T07:49:02.064Z",
	"account" => Account.schema().example,
	"status" => Status.schema().example
	}
	}
	end

	defp notification_type do
	%Schema{
	type: :string,
	enum: [
	"follow",
	"favourite",
	"reblog",
	"mention",
	- "poll",
	"pleroma:emoji_reaction",
	"pleroma:chat_mention",
	"move",
	"follow_request"
	],
	description: """
	The type of event that resulted in the notification.

	- `follow` - Someone followed you
	- `mention` - Someone mentioned you in their status
	- `reblog` - Someone boosted one of your statuses
	- `favourite` - Someone favourited one of your statuses
	- `poll` - A poll you have voted in or created has ended
	- `move` - Someone moved their account
	- `pleroma:emoji_reaction` - Someone reacted with emoji to your status
	"""
	}
	end

	defp id_param do
	Operation.parameter(:id, :path, :string, "Notification ID",
	example: "123",
	required: true
	)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	index 7cdd8f458..c38c2b895 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	@@ -1,414 +1,415 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountController do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper,
	only: [
	add_link_headers: 2,
	truthy_param?: 1,
	assign_account_by_id: 2,
	embed_relationships?: 1,
	json_response: 3
	]

	alias Pleroma.Maps
	alias Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug
	alias Pleroma.Plugs.OAuthScopesPlug
	alias Pleroma.Plugs.RateLimiter
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.ListView
	alias Pleroma.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.MastodonAPI.MastodonAPIController
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.TwitterAPI.TwitterAPI

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(:skip_plug, [OAuthScopesPlug, EnsurePublicOrAuthenticatedPlug] when action == :create)

	plug(:skip_plug, EnsurePublicOrAuthenticatedPlug when action in [:show, :statuses])

	plug(
	OAuthScopesPlug,
	%{fallback: :proceed_unauthenticated, scopes: ["read:accounts"]}
	when action in [:show, :followers, :following]
	)

	plug(
	OAuthScopesPlug,
	%{fallback: :proceed_unauthenticated, scopes: ["read:statuses"]}
	when action == :statuses
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:accounts"]}
	when action in [:verify_credentials, :endorsements, :identity_proofs]
	)

	plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action == :update_credentials)

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

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "read:blocks"]} when action == :blocks
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:blocks"]} when action in [:block, :unblock]
	)

	plug(OAuthScopesPlug, %{scopes: ["read:follows"]} when action == :relationships)

	plug(
	OAuthScopesPlug,
	%{scopes: ["follow", "write:follows"]} when action in [:follow_by_uri, :follow, :unfollow]
	)

	plug(OAuthScopesPlug, %{scopes: ["follow", "read:mutes"]} when action == :mutes)

	plug(OAuthScopesPlug, %{scopes: ["follow", "write:mutes"]} when action in [:mute, :unmute])

	@relationship_actions [:follow, :unfollow]
	@needs_account ~W(followers following lists follow unfollow mute unmute block unblock)a

	plug(
	RateLimiter,
	[name: :relation_id_action, params: [:id, :uri]] when action in @relationship_actions
	)

	plug(RateLimiter, [name: :relations_actions] when action in @relationship_actions)
	plug(RateLimiter, [name: :app_account_creation] when action == :create)
	plug(:assign_account_by_id when action in @needs_account)

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.AccountOperation

	@doc "POST /api/v1/accounts"
	def create(%{assigns: %{app: app}, body_params: params} = conn, _params) do
	with :ok <- validate_email_param(params),
	:ok <- TwitterAPI.validate_captcha(app, params),
	{:ok, user} <- TwitterAPI.register_user(params, need_confirmation: true),
	{:ok, token} <- Token.create_token(app, user, %{scopes: app.scopes}) do
	json(conn, %{
	token_type: "Bearer",
	access_token: token.token,
	scope: app.scopes,
	created_at: Token.Utils.format_created_at(token)
	})
	else
	{:error, error} -> json_response(conn, :bad_request, %{error: error})
	end
	end

	def create(%{assigns: %{app: _app}} = conn, _) do
	render_error(conn, :bad_request, "Missing parameters")
	end

	def create(conn, _) do
	render_error(conn, :forbidden, "Invalid credentials")
	end

	defp validate_email_param(%{email: email}) when not is_nil(email), do: :ok

	defp validate_email_param(_) do
	case Pleroma.Config.get([:instance, :account_activation_required]) do
	true -> {:error, dgettext("errors", "Missing parameter: %{name}", name: "email")}
	_ -> :ok
	end
	end

	@doc "GET /api/v1/accounts/verify_credentials"
	def verify_credentials(%{assigns: %{user: user}} = conn, _) do
	chat_token = Phoenix.Token.sign(conn, "user socket", user.id)

	render(conn, "show.json",
	user: user,
	for: user,
	with_pleroma_settings: true,
	with_chat_token: chat_token
	)
	end

	@doc "PATCH /api/v1/accounts/update_credentials"
	def update_credentials(%{assigns: %{user: user}, body_params: params} = conn, _params) do
	params =
	params
	\|> Enum.filter(fn {_, value} -> not is_nil(value) end)
	\|> Enum.into(%{})

	user_params =
	[
	:no_rich_text,
	:locked,
	:hide_followers_count,
	:hide_follows_count,
	:hide_followers,
	:hide_follows,
	:hide_favorites,
	:show_role,
	:skip_thread_containment,
	:allow_following_move,
	:discoverable
	]
	\|> Enum.reduce(%{}, fn key, acc ->
	Maps.put_if_present(acc, key, params[key], &{:ok, truthy_param?(&1)})
	end)
	\|> Maps.put_if_present(:name, params[:display_name])
	\|> Maps.put_if_present(:bio, params[:note])
	+ \|> Maps.put_if_present(:raw_bio, params[:note])
	\|> Maps.put_if_present(:avatar, params[:avatar])
	\|> Maps.put_if_present(:banner, params[:header])
	\|> Maps.put_if_present(:background, params[:pleroma_background_image])
	\|> Maps.put_if_present(
	:raw_fields,
	params[:fields_attributes],
	&{:ok, normalize_fields_attributes(&1)}
	)
	\|> Maps.put_if_present(:pleroma_settings_store, params[:pleroma_settings_store])
	\|> Maps.put_if_present(:default_scope, params[:default_scope])
	\|> Maps.put_if_present(:default_scope, params["source"]["privacy"])
	\|> Maps.put_if_present(:actor_type, params[:actor_type])

	changeset = User.update_changeset(user, user_params)

	with {:ok, user} <- User.update_and_set_cache(changeset) do
	user
	\|> build_update_activity_params()
	\|> ActivityPub.update()

	render(conn, "show.json", user: user, for: user, with_pleroma_settings: true)
	else
	_e -> render_error(conn, :forbidden, "Invalid request")
	end
	end

	# Hotfix, handling will be redone with the pipeline
	defp build_update_activity_params(user) do
	object =
	Pleroma.Web.ActivityPub.UserView.render("user.json", user: user)
	\|> Map.delete("@context")

	%{
	local: true,
	to: [user.follower_address],
	cc: [],
	object: object,
	actor: user.ap_id
	}
	end

	defp normalize_fields_attributes(fields) do
	if Enum.all?(fields, &is_tuple/1) do
	Enum.map(fields, fn {_, v} -> v end)
	else
	Enum.map(fields, fn
	%{} = field -> %{"name" => field.name, "value" => field.value}
	field -> field
	end)
	end
	end

	@doc "GET /api/v1/accounts/relationships"
	def relationships(%{assigns: %{user: user}} = conn, %{id: id}) do
	targets = User.get_all_by_ids(List.wrap(id))

	render(conn, "relationships.json", user: user, targets: targets)
	end

	# Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
	def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, [])

	@doc "GET /api/v1/accounts/:id"
	def show(%{assigns: %{user: for_user}} = conn, %{id: nickname_or_id}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id, for: for_user),
	true <- User.visible_for?(user, for_user) do
	render(conn, "show.json", user: user, for: for_user)
	else
	_e -> render_error(conn, :not_found, "Can't find user")
	end
	end

	@doc "GET /api/v1/accounts/:id/statuses"
	def statuses(%{assigns: %{user: reading_user}} = conn, params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(params.id, for: reading_user),
	true <- User.visible_for?(user, reading_user) do
	params =
	params
	\|> Map.delete(:tagged)
	\|> Map.put(:tag, params[:tagged])

	activities = ActivityPub.fetch_user_activities(user, reading_user, params)

	conn
	\|> add_link_headers(activities)
	\|> put_view(StatusView)
	\|> render("index.json",
	activities: activities,
	for: reading_user,
	as: :activity
	)
	else
	_e -> render_error(conn, :not_found, "Can't find user")
	end
	end

	@doc "GET /api/v1/accounts/:id/followers"
	def followers(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Enum.map(fn {key, value} -> {to_string(key), value} end)
	\|> Enum.into(%{})

	followers =
	cond do
	for_user && user.id == for_user.id -> MastodonAPI.get_followers(user, params)
	user.hide_followers -> []
	true -> MastodonAPI.get_followers(user, params)
	end

	conn
	\|> add_link_headers(followers)
	# https://git.pleroma.social/pleroma/pleroma-fe/-/issues/838#note_59223
	\|> render("index.json",
	for: for_user,
	users: followers,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/accounts/:id/following"
	def following(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Enum.map(fn {key, value} -> {to_string(key), value} end)
	\|> Enum.into(%{})

	followers =
	cond do
	for_user && user.id == for_user.id -> MastodonAPI.get_friends(user, params)
	user.hide_follows -> []
	true -> MastodonAPI.get_friends(user, params)
	end

	conn
	\|> add_link_headers(followers)
	# https://git.pleroma.social/pleroma/pleroma-fe/-/issues/838#note_59223
	\|> render("index.json",
	for: for_user,
	users: followers,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/accounts/:id/lists"
	def lists(%{assigns: %{user: user, account: account}} = conn, _params) do
	lists = Pleroma.List.get_lists_account_belongs(user, account)

	conn
	\|> put_view(ListView)
	\|> render("index.json", lists: lists)
	end

	@doc "POST /api/v1/accounts/:id/follow"
	def follow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not follow yourself"}
	end

	def follow(%{assigns: %{user: follower, account: followed}} = conn, params) do
	with {:ok, follower} <- MastodonAPI.follow(follower, followed, params) do
	render(conn, "relationship.json", user: follower, target: followed)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unfollow"
	def unfollow(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not unfollow yourself"}
	end

	def unfollow(%{assigns: %{user: follower, account: followed}} = conn, _params) do
	with {:ok, follower} <- CommonAPI.unfollow(follower, followed) do
	render(conn, "relationship.json", user: follower, target: followed)
	end
	end

	@doc "POST /api/v1/accounts/:id/mute"
	def mute(%{assigns: %{user: muter, account: muted}, body_params: params} = conn, _params) do
	with {:ok, _user_relationships} <- User.mute(muter, muted, params.notifications) do
	render(conn, "relationship.json", user: muter, target: muted)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unmute"
	def unmute(%{assigns: %{user: muter, account: muted}} = conn, _params) do
	with {:ok, _user_relationships} <- User.unmute(muter, muted) do
	render(conn, "relationship.json", user: muter, target: muted)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/block"
	def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
	with {:ok, _user_block} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	render(conn, "relationship.json", user: blocker, target: blocked)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/accounts/:id/unblock"
	def unblock(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
	with {:ok, _activity} <- CommonAPI.unblock(blocker, blocked) do
	render(conn, "relationship.json", user: blocker, target: blocked)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

	@doc "POST /api/v1/follows"
	def follow_by_uri(%{body_params: %{uri: uri}} = conn, _) do
	case User.get_cached_by_nickname(uri) do
	%User{} = user ->
	conn
	\|> assign(:account, user)
	\|> follow(%{})

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

	@doc "GET /api/v1/mutes"
	def mutes(%{assigns: %{user: user}} = conn, _) do
	users = User.muted_users(user, _restrict_deactivated = true)
	render(conn, "index.json", users: users, for: user, as: :user)
	end

	@doc "GET /api/v1/blocks"
	def blocks(%{assigns: %{user: user}} = conn, _) do
	users = User.blocked_users(user, _restrict_deactivated = true)
	render(conn, "index.json", users: users, for: user, as: :user)
	end

	@doc "GET /api/v1/endorsements"
	def endorsements(conn, params), do: MastodonAPIController.empty_array(conn, params)

	@doc "GET /api/v1/identity_proofs"
	def identity_proofs(conn, params), do: MastodonAPIController.empty_array(conn, params)
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
	index 9fc06bf9d..68beb69b8 100644
	--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
	@@ -1,385 +1,374 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountView do
	use Pleroma.Web, :view

	alias Pleroma.FollowingRelationship
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MediaProxy

	def render("index.json", %{users: users} = opts) do
	reading_user = opts[:for]

	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	is_nil(reading_user) \|\| !opts[:embed_relationships] ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	UserRelationship.view_relationships_option(reading_user, users)
	end

	opts = Map.put(opts, :relationships, relationships_opt)

	users
	\|> render_many(AccountView, "show.json", opts)
	\|> Enum.filter(&Enum.any?/1)
	end

	def render("show.json", %{user: user} = opts) do
	if User.visible_for?(user, opts[:for]) do
	do_render("show.json", opts)
	else
	%{}
	end
	end

	def render("mention.json", %{user: user}) do
	%{
	id: to_string(user.id),
	acct: user.nickname,
	username: username_from_nickname(user.nickname),
	url: user.uri \|\| user.ap_id
	}
	end

	def render("relationship.json", %{user: nil, target: _target}) do
	%{}
	end

	def render(
	"relationship.json",
	%{user: %User{} = reading_user, target: %User{} = target} = opts
	) do
	user_relationships = get_in(opts, [:relationships, :user_relationships])
	following_relationships = get_in(opts, [:relationships, :following_relationships])

	follow_state =
	if following_relationships do
	user_to_target_following_relation =
	FollowingRelationship.find(following_relationships, reading_user, target)

	User.get_follow_state(reading_user, target, user_to_target_following_relation)
	else
	User.get_follow_state(reading_user, target)
	end

	followed_by =
	if following_relationships do
	case FollowingRelationship.find(following_relationships, target, reading_user) do
	%{state: :follow_accept} -> true
	_ -> false
	end
	else
	User.following?(target, reading_user)
	end

	# NOTE: adjust UserRelationship.view_relationships_option/2 on new relation-related flags
	%{
	id: to_string(target.id),
	following: follow_state == :follow_accept,
	followed_by: followed_by,
	blocking:
	UserRelationship.exists?(
	user_relationships,
	:block,
	reading_user,
	target,
	&User.blocks_user?(&1, &2)
	),
	blocked_by:
	UserRelationship.exists?(
	user_relationships,
	:block,
	target,
	reading_user,
	&User.blocks_user?(&1, &2)
	),
	muting:
	UserRelationship.exists?(
	user_relationships,
	:mute,
	reading_user,
	target,
	&User.mutes?(&1, &2)
	),
	muting_notifications:
	UserRelationship.exists?(
	user_relationships,
	:notification_mute,
	reading_user,
	target,
	&User.muted_notifications?(&1, &2)
	),
	subscribing:
	UserRelationship.exists?(
	user_relationships,
	:inverse_subscription,
	target,
	reading_user,
	&User.subscribed_to?(&2, &1)
	),
	requested: follow_state == :follow_pending,
	domain_blocking: User.blocks_domain?(reading_user, target),
	showing_reblogs:
	not UserRelationship.exists?(
	user_relationships,
	:reblog_mute,
	reading_user,
	target,
	&User.muting_reblogs?(&1, &2)
	),
	endorsed: false
	}
	end

	def render("relationships.json", %{user: user, targets: targets} = opts) do
	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	is_nil(user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	UserRelationship.view_relationships_option(user, targets)
	end

	render_opts = %{as: :target, user: user, relationships: relationships_opt}
	render_many(targets, AccountView, "relationship.json", render_opts)
	end

	defp do_render("show.json", %{user: user} = opts) do
	user = User.sanitize_html(user, User.html_filter_policy(opts[:for]))
	display_name = user.name \|\| user.nickname

	image = User.avatar_url(user) \|> MediaProxy.url()
	header = User.banner_url(user) \|> MediaProxy.url()

	following_count =
	if !user.hide_follows_count or !user.hide_follows or opts[:for] == user do
	user.following_count \|\| 0
	else
	0
	end

	followers_count =
	if !user.hide_followers_count or !user.hide_followers or opts[:for] == user do
	user.follower_count \|\| 0
	else
	0
	end

	bot = user.actor_type in ["Application", "Service"]

	emojis =
	Enum.map(user.emoji, fn {shortcode, raw_url} ->
	url = MediaProxy.url(raw_url)

	%{
	shortcode: shortcode,
	url: url,
	static_url: url,
	visible_in_picker: false
	}
	end)

	relationship =
	if opts[:embed_relationships] do
	render("relationship.json", %{
	user: opts[:for],
	target: user,
	relationships: opts[:relationships]
	})
	else
	%{}
	end

	%{
	id: to_string(user.id),
	username: username_from_nickname(user.nickname),
	acct: user.nickname,
	display_name: display_name,
	locked: user.locked,
	created_at: Utils.to_masto_date(user.inserted_at),
	followers_count: followers_count,
	following_count: following_count,
	statuses_count: user.note_count,
	note: user.bio \|\| "",
	url: user.uri \|\| user.ap_id,
	avatar: image,
	avatar_static: image,
	header: header,
	header_static: header,
	emojis: emojis,
	fields: user.fields,
	bot: bot,
	source: %{
	- note: prepare_user_bio(user),
	+ note: user.raw_bio \|\| "",
	sensitive: false,
	fields: user.raw_fields,
	pleroma: %{
	discoverable: user.discoverable,
	actor_type: user.actor_type
	}
	},

	# Pleroma extension
	pleroma: %{
	ap_id: user.ap_id,
	confirmation_pending: user.confirmation_pending,
	tags: user.tags,
	hide_followers_count: user.hide_followers_count,
	hide_follows_count: user.hide_follows_count,
	hide_followers: user.hide_followers,
	hide_follows: user.hide_follows,
	hide_favorites: user.hide_favorites,
	relationship: relationship,
	skip_thread_containment: user.skip_thread_containment,
	background_image: image_url(user.background) \|> MediaProxy.url()
	}
	}
	\|> maybe_put_role(user, opts[:for])
	\|> maybe_put_settings(user, opts[:for], opts)
	\|> maybe_put_notification_settings(user, opts[:for])
	\|> maybe_put_settings_store(user, opts[:for], opts)
	\|> maybe_put_chat_token(user, opts[:for], opts)
	\|> maybe_put_activation_status(user, opts[:for])
	\|> maybe_put_follow_requests_count(user, opts[:for])
	\|> maybe_put_allow_following_move(user, opts[:for])
	\|> maybe_put_unread_conversation_count(user, opts[:for])
	\|> maybe_put_unread_notification_count(user, opts[:for])
	end

	- defp prepare_user_bio(%User{bio: ""}), do: ""
	-
	- defp prepare_user_bio(%User{bio: bio}) when is_binary(bio) do
	- bio
	- \|> String.replace(~r(<br */?>), "\n")
	- \|> Pleroma.HTML.strip_tags()
	- \|> HtmlEntities.decode()
	- end
	-
	- defp prepare_user_bio(_), do: ""
	-
	defp username_from_nickname(string) when is_binary(string) do
	hd(String.split(string, "@"))
	end

	defp username_from_nickname(_), do: nil

	defp maybe_put_follow_requests_count(
	data,
	%User{id: user_id} = user,
	%User{id: user_id}
	) do
	count =
	User.get_follow_requests(user)
	\|> length()

	data
	\|> Kernel.put_in([:follow_requests_count], count)
	end

	defp maybe_put_follow_requests_count(data, _, _), do: data

	defp maybe_put_settings(
	data,
	%User{id: user_id} = user,
	%User{id: user_id},
	_opts
	) do
	data
	\|> Kernel.put_in([:source, :privacy], user.default_scope)
	\|> Kernel.put_in([:source, :pleroma, :show_role], user.show_role)
	\|> Kernel.put_in([:source, :pleroma, :no_rich_text], user.no_rich_text)
	end

	defp maybe_put_settings(data, _, _, _), do: data

	defp maybe_put_settings_store(data, %User{} = user, %User{}, %{
	with_pleroma_settings: true
	}) do
	data
	\|> Kernel.put_in([:pleroma, :settings_store], user.pleroma_settings_store)
	end

	defp maybe_put_settings_store(data, _, _, _), do: data

	defp maybe_put_chat_token(data, %User{id: id}, %User{id: id}, %{
	with_chat_token: token
	}) do
	data
	\|> Kernel.put_in([:pleroma, :chat_token], token)
	end

	defp maybe_put_chat_token(data, _, _, _), do: data

	defp maybe_put_role(data, %User{show_role: true} = user, _) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
	end

	defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
	end

	defp maybe_put_role(data, _, _), do: data

	defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
	Kernel.put_in(
	data,
	[:pleroma, :notification_settings],
	Map.from_struct(user.notification_settings)
	)
	end

	defp maybe_put_notification_settings(data, _, _), do: data

	defp maybe_put_allow_following_move(data, %User{id: user_id} = user, %User{id: user_id}) do
	Kernel.put_in(data, [:pleroma, :allow_following_move], user.allow_following_move)
	end

	defp maybe_put_allow_following_move(data, _, _), do: data

	defp maybe_put_activation_status(data, user, %User{is_admin: true}) do
	Kernel.put_in(data, [:pleroma, :deactivated], user.deactivated)
	end

	defp maybe_put_activation_status(data, _, _), do: data

	defp maybe_put_unread_conversation_count(data, %User{id: user_id} = user, %User{id: user_id}) do
	data
	\|> Kernel.put_in(
	[:pleroma, :unread_conversation_count],
	user.unread_conversation_count
	)
	end

	defp maybe_put_unread_conversation_count(data, _, _), do: data

	defp maybe_put_unread_notification_count(data, %User{id: user_id}, %User{id: user_id} = user) do
	Kernel.put_in(
	data,
	[:pleroma, :unread_notifications_count],
	Pleroma.Notification.unread_notifications_count(user)
	)
	end

	defp maybe_put_unread_notification_count(data, _, _), do: data

	defp image_url(%{"url" => [%{"href" => href} \| _]}), do: href
	defp image_url(_), do: nil
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/conversation_view.ex b/lib/pleroma/web/mastodon_api/views/conversation_view.ex
	index fbe618377..06f0c1728 100644
	--- a/lib/pleroma/web/mastodon_api/views/conversation_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/conversation_view.ex
	@@ -1,47 +1,50 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.ConversationView do
	use Pleroma.Web, :view

	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView

	def render("participations.json", %{participations: participations, for: user}) do
	safe_render_many(participations, __MODULE__, "participation.json", %{
	as: :participation,
	for: user
	})
	end

	def render("participation.json", %{participation: participation, for: user}) do
	participation = Repo.preload(participation, conversation: [], recipients: [])

	last_activity_id =
	with nil <- participation.last_activity_id do
	- ActivityPub.fetch_latest_activity_id_for_context(participation.conversation.ap_id, %{
	- user: user,
	- blocking_user: user
	- })
	+ ActivityPub.fetch_latest_direct_activity_id_for_context(
	+ participation.conversation.ap_id,
	+ %{
	+ user: user,
	+ blocking_user: user
	+ }
	+ )
	end

	activity = Activity.get_by_id_with_object(last_activity_id)
	# Conversations return all users except the current user.
	users = Enum.reject(participation.recipients, &(&1.id == user.id))

	%{
	id: participation.id \|> to_string(),
	accounts: render(AccountView, "index.json", users: users, as: :user),
	unread: !participation.read,
	last_status:
	render(StatusView, "show.json",
	activity: activity,
	direct_conversation_id: participation.id
	)
	}
	end
	end
	diff --git a/mix.exs b/mix.exs
	index 03b060bc0..6040c994e 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,317 +1,317 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("2.0.50"),
	- elixir: "~> 1.8",
	+ 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
	# Uncomment this if you need testing configurable_from_database logic
	# defp warnings_as_errors(:dev), 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.8"},
	{:tzdata, "~> 0.5.21"},
	{:plug_cowboy, "~> 2.0"},
	{:phoenix_pubsub, "~> 1.1"},
	{:phoenix_ecto, "~> 4.0"},
	{:ecto_enum, "~> 1.4"},
	{:ecto_sql, "~> 3.3.2"},
	{:postgrex, ">= 0.13.5"},
	{:oban, "~> 1.2"},
	{:gettext, "~> 0.15"},
	{:pbkdf2_elixir, "~> 1.0"},
	{:bcrypt_elixir, "~> 2.0"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:fast_sanitize, "~> 0.1"},
	{:html_entities, "~> 0.5", override: true},
	{:phoenix_html, "~> 2.10"},
	{:calendar, "~> 0.17.4"},
	{:cachex, "~> 3.2"},
	{:poison, "~> 3.0", override: true},
	# {:tesla, "~> 1.3", override: true},
	{:tesla,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/tesla.git",
	ref: "61b7503cef33f00834f78ddfafe0d5d9dec2270b",
	override: true},
	{:castore, "~> 0.1"},
	{:cowlib, "~> 2.8", override: true},
	{:gun,
	github: "ninenines/gun", ref: "e1a69b36b180a574c0ac314ced9613fdd52312cc", override: true},
	{:jason, "~> 1.0"},
	{:mogrify, "~> 0.6.1"},
	{:ex_aws, "~> 2.1"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.6.6"},
	{:earmark, "~> 1.3"},
	{:bbcode_pleroma, "~> 0.2.0"},
	{:ex_machina, "~> 2.3", only: :test},
	{:credo, "~> 1.1.0", only: [:dev, :test], runtime: false},
	{:mock, "~> 0.3.3", only: :test},
	{:crypt,
	git: "https://github.com/msantos/crypt", ref: "f63a705f92c26955977ee62a313012e309a4d77a"},
	{:cors_plug, "~> 1.5"},
	{:ex_doc, "~> 0.21", only: :dev, runtime: false},
	{:web_push_encryption, "~> 0.2.1"},
	{:swoosh, "~> 0.23.2"},
	{:phoenix_swoosh, "~> 0.2"},
	{:gen_smtp, "~> 0.13"},
	{:websocket_client, git: "https://github.com/jeremyong/websocket_client.git", only: :test},
	{:ex_syslogger, "~> 1.4"},
	{:floki, "~> 0.25"},
	{:timex, "~> 3.5"},
	{:ueberauth, "~> 0.4"},
	{:auto_linker,
	git: "https://git.pleroma.social/pleroma/auto_linker.git",
	ref: "95e8188490e97505c56636c1379ffdf036c1fdde"},
	{:http_signatures,
	git: "https://git.pleroma.social/pleroma/http_signatures.git",
	ref: "293d77bb6f4a67ac8bde1428735c3b42f22cbb30"},
	{:telemetry, "~> 0.3"},
	{:poolboy, "~> 1.5"},
	{: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.10.2"},
	{:esshd, "~> 0.1.0", runtime: Application.get_env(:esshd, :enabled, false)},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:excoveralls, "~> 0.12.1", only: :test},
	{:flake_id, "~> 0.1.0"},
	{: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"},
	{:mox, "~> 0.5", only: :test},
	{:restarter, path: "./restarter"},
	{:open_api_spex,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/open_api_spex.git",
	ref: "f296ac0924ba3cf79c7a588c4c252889df4c2edd"}
	] ++ 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"]
	]
	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

	# Pre-release version, denoted from patch version with a hyphen
	{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"])

	git_pre_release =
	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 ->
	""
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with {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
	_ -> "stable"
	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/priv/repo/migrations/20200322174133_user_raw_bio.exs b/priv/repo/migrations/20200322174133_user_raw_bio.exs
	new file mode 100644
	index 000000000..ddf9be4f5
	--- /dev/null
	+++ b/priv/repo/migrations/20200322174133_user_raw_bio.exs
	@@ -0,0 +1,9 @@
	+defmodule Pleroma.Repo.Migrations.UserRawBio do
	+ use Ecto.Migration
	+
	+ def change do
	+ alter table(:users) do
	+ add_if_not_exists(:raw_bio, :text)
	+ end
	+ end
	+end
	diff --git a/priv/repo/migrations/20200328193433_populate_user_raw_bio.exs b/priv/repo/migrations/20200328193433_populate_user_raw_bio.exs
	new file mode 100644
	index 000000000..cb35db3f5
	--- /dev/null
	+++ b/priv/repo/migrations/20200328193433_populate_user_raw_bio.exs
	@@ -0,0 +1,25 @@
	+defmodule Pleroma.Repo.Migrations.PopulateUserRawBio do
	+ use Ecto.Migration
	+ import Ecto.Query
	+ alias Pleroma.User
	+ alias Pleroma.Repo
	+
	+ def change do
	+ {:ok, _} = Application.ensure_all_started(:fast_sanitize)
	+
	+ User.Query.build(%{local: true})
	+ \|> select([u], struct(u, [:id, :ap_id, :bio]))
	+ \|> Repo.stream()
	+ \|> Enum.each(fn %{bio: bio} = user ->
	+ if bio do
	+ raw_bio =
	+ bio
	+ \|> String.replace(~r(<br */?>), "\n")
	+ \|> Pleroma.HTML.strip_tags()
	+
	+ Ecto.Changeset.cast(user, %{raw_bio: raw_bio}, [:raw_bio])
	+ \|> Repo.update()
	+ end
	+ end)
	+ end
	+end
	diff --git a/test/config/config_db_test.exs b/test/config/config_db_test.exs
	index 336de7359..3895e2cda 100644
	--- a/test/config/config_db_test.exs
	+++ b/test/config/config_db_test.exs
	@@ -1,711 +1,546 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ConfigDBTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory
	alias Pleroma.ConfigDB

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

	assert config == ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end

	- test "create/1" do
	- {:ok, config} = ConfigDB.create(%{group: ":pleroma", key: ":some_key", value: "some_value"})
	- assert config == ConfigDB.get_by_params(%{group: ":pleroma", key: ":some_key"})
	- end
	-
	- test "update/1" do
	- config = insert(:config)
	- {:ok, updated} = ConfigDB.update(config, %{value: "some_value"})
	- loaded = ConfigDB.get_by_params(%{group: config.group, key: config.key})
	- assert loaded == updated
	- end
	-
	test "get_all_as_keyword/0" do
	saved = insert(:config)
	- insert(:config, group: ":quack", key: ":level", value: ConfigDB.to_binary(:info))
	- insert(:config, group: ":quack", key: ":meta", value: ConfigDB.to_binary([:none]))
	+ insert(:config, group: ":quack", key: ":level", value: :info)
	+ insert(:config, group: ":quack", key: ":meta", value: [:none])

	insert(:config,
	group: ":quack",
	key: ":webhook_url",
	- value: ConfigDB.to_binary("https://hooks.slack.com/services/KEY/some_val")
	+ value: "https://hooks.slack.com/services/KEY/some_val"
	)

	config = ConfigDB.get_all_as_keyword()

	assert config[:pleroma] == [
	- {ConfigDB.from_string(saved.key), ConfigDB.from_binary(saved.value)}
	+ {saved.key, saved.value}
	]

	assert config[:quack][:level] == :info
	assert config[:quack][:meta] == [:none]
	assert config[:quack][:webhook_url] == "https://hooks.slack.com/services/KEY/some_val"
	end

	describe "update_or_create/1" do
	test "common" do
	config = insert(:config)
	- key2 = "another_key"
	+ key2 = :another_key

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

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

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

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

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

	- assert config1.value == ConfigDB.transform("new_value")
	- assert config2.value == ConfigDB.transform("another_value")
	+ assert config1.value == [a: 1, b: 2, c: "new_value"]
	+ assert config2.value == "another_value"
	end

	test "partial update" do
	- config = insert(:config, value: ConfigDB.to_binary(key1: "val1", key2: :val2))
	+ config = insert(:config, value: [key1: "val1", key2: :val2])

	- {:ok, _config} =
	+ {:ok, config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: [key1: :val1, key3: :val3]
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	- value = ConfigDB.from_binary(updated.value)
	- assert length(value) == 3
	- assert value[:key1] == :val1
	- assert value[:key2] == :val2
	- assert value[:key3] == :val3
	+ assert config.value == updated.value
	+ assert updated.value[:key1] == :val1
	+ assert updated.value[:key2] == :val2
	+ assert updated.value[:key3] == :val3
	end

	test "deep merge" do
	- config = insert(:config, value: ConfigDB.to_binary(key1: "val1", key2: [k1: :v1, k2: "v2"]))
	+ config = insert(:config, value: [key1: "val1", key2: [k1: :v1, k2: "v2"]])

	{:ok, config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: [key1: :val1, key2: [k2: :v2, k3: :v3], key3: :val3]
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert config.value == updated.value
	-
	- value = ConfigDB.from_binary(updated.value)
	- assert value[:key1] == :val1
	- assert value[:key2] == [k1: :v1, k2: :v2, k3: :v3]
	- assert value[:key3] == :val3
	+ assert updated.value[:key1] == :val1
	+ assert updated.value[:key2] == [k1: :v1, k2: :v2, k3: :v3]
	+ assert updated.value[:key3] == :val3
	end

	test "only full update for some keys" do
	- config1 = insert(:config, key: ":ecto_repos", value: ConfigDB.to_binary(repo: Pleroma.Repo))
	+ config1 = insert(:config, key: :ecto_repos, value: [repo: Pleroma.Repo])

	- config2 =
	- insert(:config, group: ":cors_plug", key: ":max_age", value: ConfigDB.to_binary(18))
	+ config2 = insert(:config, group: :cors_plug, key: :max_age, value: 18)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config1.group,
	key: config1.key,
	value: [another_repo: [Pleroma.Repo]]
	})

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config2.group,
	key: config2.key,
	value: 777
	})

	updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
	updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})

	- assert ConfigDB.from_binary(updated1.value) == [another_repo: [Pleroma.Repo]]
	- assert ConfigDB.from_binary(updated2.value) == 777
	+ assert updated1.value == [another_repo: [Pleroma.Repo]]
	+ assert updated2.value == 777
	end

	test "full update if value is not keyword" do
	config =
	insert(:config,
	group: ":tesla",
	key: ":adapter",
	- value: ConfigDB.to_binary(Tesla.Adapter.Hackney)
	+ value: Tesla.Adapter.Hackney
	)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config.group,
	key: config.key,
	value: Tesla.Adapter.Httpc
	})

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	- assert ConfigDB.from_binary(updated.value) == Tesla.Adapter.Httpc
	+ assert updated.value == Tesla.Adapter.Httpc
	end

	test "only full update for some subkeys" do
	config1 =
	insert(:config,
	key: ":emoji",
	- value: ConfigDB.to_binary(groups: [a: 1, b: 2], key: [a: 1])
	+ value: [groups: [a: 1, b: 2], key: [a: 1]]
	)

	config2 =
	insert(:config,
	key: ":assets",
	- value: ConfigDB.to_binary(mascots: [a: 1, b: 2], key: [a: 1])
	+ value: [mascots: [a: 1, b: 2], key: [a: 1]]
	)

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config1.group,
	key: config1.key,
	value: [groups: [c: 3, d: 4], key: [b: 2]]
	})

	{:ok, _config} =
	ConfigDB.update_or_create(%{
	group: config2.group,
	key: config2.key,
	value: [mascots: [c: 3, d: 4], key: [b: 2]]
	})

	updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
	updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})

	- assert ConfigDB.from_binary(updated1.value) == [groups: [c: 3, d: 4], key: [a: 1, b: 2]]
	- assert ConfigDB.from_binary(updated2.value) == [mascots: [c: 3, d: 4], key: [a: 1, b: 2]]
	+ assert updated1.value == [groups: [c: 3, d: 4], key: [a: 1, b: 2]]
	+ assert updated2.value == [mascots: [c: 3, d: 4], key: [a: 1, b: 2]]
	end
	end

	describe "delete/1" do
	test "error on deleting non existing setting" do
	{:error, error} = ConfigDB.delete(%{group: ":pleroma", key: ":key"})
	assert error =~ "Config with params %{group: \":pleroma\", key: \":key\"} not found"
	end

	test "full delete" do
	config = insert(:config)
	{:ok, deleted} = ConfigDB.delete(%{group: config.group, key: config.key})
	assert Ecto.get_meta(deleted, :state) == :deleted
	refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end

	test "partial subkeys delete" do
	- config = insert(:config, value: ConfigDB.to_binary(groups: [a: 1, b: 2], key: [a: 1]))
	+ config = insert(:config, value: [groups: [a: 1, b: 2], key: [a: 1]])

	{:ok, deleted} =
	ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})

	assert Ecto.get_meta(deleted, :state) == :loaded

	- assert deleted.value == ConfigDB.to_binary(key: [a: 1])
	+ assert deleted.value == [key: [a: 1]]

	updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})

	assert updated.value == deleted.value
	end

	test "full delete if remaining value after subkeys deletion is empty list" do
	- config = insert(:config, value: ConfigDB.to_binary(groups: [a: 1, b: 2]))
	+ config = insert(:config, value: [groups: [a: 1, b: 2]])

	{:ok, deleted} =
	ConfigDB.delete(%{group: config.group, key: config.key, subkeys: [":groups"]})

	assert Ecto.get_meta(deleted, :state) == :deleted

	refute ConfigDB.get_by_params(%{group: config.group, key: config.key})
	end
	end

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

	test "boolean" do
	- binary = ConfigDB.transform(false)
	- assert binary == :erlang.term_to_binary(false)
	- assert ConfigDB.from_binary(binary) == false
	+ assert ConfigDB.to_elixir_types(false) == false
	end

	test "nil" do
	- binary = ConfigDB.transform(nil)
	- assert binary == :erlang.term_to_binary(nil)
	- assert ConfigDB.from_binary(binary) == nil
	+ assert ConfigDB.to_elixir_types(nil) == nil
	end

	test "integer" do
	- binary = ConfigDB.transform(150)
	- assert binary == :erlang.term_to_binary(150)
	- assert ConfigDB.from_binary(binary) == 150
	+ assert ConfigDB.to_elixir_types(150) == 150
	end

	test "atom" do
	- binary = ConfigDB.transform(":atom")
	- assert binary == :erlang.term_to_binary(:atom)
	- assert ConfigDB.from_binary(binary) == :atom
	+ assert ConfigDB.to_elixir_types(":atom") == :atom
	end

	test "ssl options" do
	- binary = ConfigDB.transform([":tlsv1", ":tlsv1.1", ":tlsv1.2"])
	- assert binary == :erlang.term_to_binary([:tlsv1, :"tlsv1.1", :"tlsv1.2"])
	- assert ConfigDB.from_binary(binary) == [:tlsv1, :"tlsv1.1", :"tlsv1.2"]
	+ assert ConfigDB.to_elixir_types([":tlsv1", ":tlsv1.1", ":tlsv1.2"]) == [
	+ :tlsv1,
	+ :"tlsv1.1",
	+ :"tlsv1.2"
	+ ]
	end

	test "pleroma module" do
	- binary = ConfigDB.transform("Pleroma.Bookmark")
	- assert binary == :erlang.term_to_binary(Pleroma.Bookmark)
	- assert ConfigDB.from_binary(binary) == Pleroma.Bookmark
	+ assert ConfigDB.to_elixir_types("Pleroma.Bookmark") == Pleroma.Bookmark
	end

	test "pleroma string" do
	- binary = ConfigDB.transform("Pleroma")
	- assert binary == :erlang.term_to_binary("Pleroma")
	- assert ConfigDB.from_binary(binary) == "Pleroma"
	+ assert ConfigDB.to_elixir_types("Pleroma") == "Pleroma"
	end

	test "phoenix module" do
	- binary = ConfigDB.transform("Phoenix.Socket.V1.JSONSerializer")
	- assert binary == :erlang.term_to_binary(Phoenix.Socket.V1.JSONSerializer)
	- assert ConfigDB.from_binary(binary) == Phoenix.Socket.V1.JSONSerializer
	+ assert ConfigDB.to_elixir_types("Phoenix.Socket.V1.JSONSerializer") ==
	+ Phoenix.Socket.V1.JSONSerializer
	end

	test "tesla module" do
	- binary = ConfigDB.transform("Tesla.Adapter.Hackney")
	- assert binary == :erlang.term_to_binary(Tesla.Adapter.Hackney)
	- assert ConfigDB.from_binary(binary) == Tesla.Adapter.Hackney
	+ assert ConfigDB.to_elixir_types("Tesla.Adapter.Hackney") == Tesla.Adapter.Hackney
	end

	test "ExSyslogger module" do
	- binary = ConfigDB.transform("ExSyslogger")
	- assert binary == :erlang.term_to_binary(ExSyslogger)
	- assert ConfigDB.from_binary(binary) == ExSyslogger
	+ assert ConfigDB.to_elixir_types("ExSyslogger") == ExSyslogger
	end

	test "Quack.Logger module" do
	- binary = ConfigDB.transform("Quack.Logger")
	- assert binary == :erlang.term_to_binary(Quack.Logger)
	- assert ConfigDB.from_binary(binary) == Quack.Logger
	+ assert ConfigDB.to_elixir_types("Quack.Logger") == Quack.Logger
	end

	test "Swoosh.Adapters modules" do
	- binary = ConfigDB.transform("Swoosh.Adapters.SMTP")
	- assert binary == :erlang.term_to_binary(Swoosh.Adapters.SMTP)
	- assert ConfigDB.from_binary(binary) == Swoosh.Adapters.SMTP
	- binary = ConfigDB.transform("Swoosh.Adapters.AmazonSES")
	- assert binary == :erlang.term_to_binary(Swoosh.Adapters.AmazonSES)
	- assert ConfigDB.from_binary(binary) == Swoosh.Adapters.AmazonSES
	+ assert ConfigDB.to_elixir_types("Swoosh.Adapters.SMTP") == Swoosh.Adapters.SMTP
	+ assert ConfigDB.to_elixir_types("Swoosh.Adapters.AmazonSES") == Swoosh.Adapters.AmazonSES
	end

	test "sigil" do
	- binary = ConfigDB.transform("~r[comp[lL][aA][iI][nN]er]")
	- assert binary == :erlang.term_to_binary(~r/comp[lL][aA][iI][nN]er/)
	- assert ConfigDB.from_binary(binary) == ~r/comp[lL][aA][iI][nN]er/
	+ assert ConfigDB.to_elixir_types("~r[comp[lL][aA][iI][nN]er]") == ~r/comp[lL][aA][iI][nN]er/
	end

	test "link sigil" do
	- binary = ConfigDB.transform("~r/https:\/\/example.com/")
	- assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/)
	- assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/
	+ assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/") == ~r/https:\/\/example.com/
	end

	test "link sigil with um modifiers" do
	- binary = ConfigDB.transform("~r/https:\/\/example.com/um")
	- assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/um)
	- assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/um
	+ assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/um") ==
	+ ~r/https:\/\/example.com/um
	end

	test "link sigil with i modifier" do
	- binary = ConfigDB.transform("~r/https:\/\/example.com/i")
	- assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/i)
	- assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/i
	+ assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/i") == ~r/https:\/\/example.com/i
	end

	test "link sigil with s modifier" do
	- binary = ConfigDB.transform("~r/https:\/\/example.com/s")
	- assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/s)
	- assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/s
	+ assert ConfigDB.to_elixir_types("~r/https:\/\/example.com/s") == ~r/https:\/\/example.com/s
	end

	test "raise if valid delimiter not found" do
	assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
	- ConfigDB.transform("~r/https://[]{}<>\"'()\|example.com/s")
	+ ConfigDB.to_elixir_types("~r/https://[]{}<>\"'()\|example.com/s")
	end
	end

	test "2 child tuple" do
	- binary = ConfigDB.transform(%{"tuple" => ["v1", ":v2"]})
	- assert binary == :erlang.term_to_binary({"v1", :v2})
	- assert ConfigDB.from_binary(binary) == {"v1", :v2}
	+ assert ConfigDB.to_elixir_types(%{"tuple" => ["v1", ":v2"]}) == {"v1", :v2}
	end

	test "proxy tuple with localhost" do
	- binary =
	- ConfigDB.transform(%{
	- "tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
	- })
	-
	- assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, :localhost, 1234}})
	- assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, :localhost, 1234}}
	+ assert ConfigDB.to_elixir_types(%{
	+ "tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
	+ }) == {:proxy_url, {:socks5, :localhost, 1234}}
	end

	test "proxy tuple with domain" do
	- binary =
	- ConfigDB.transform(%{
	- "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
	- })
	-
	- assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, 'domain.com', 1234}})
	- assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, 'domain.com', 1234}}
	+ assert ConfigDB.to_elixir_types(%{
	+ "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
	+ }) == {:proxy_url, {:socks5, 'domain.com', 1234}}
	end

	test "proxy tuple with ip" do
	- binary =
	- ConfigDB.transform(%{
	- "tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
	- })
	-
	- assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}})
	- assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
	+ assert ConfigDB.to_elixir_types(%{
	+ "tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
	+ }) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
	end

	test "tuple with n childs" do
	- binary =
	- ConfigDB.transform(%{
	- "tuple" => [
	- "v1",
	- ":v2",
	- "Pleroma.Bookmark",
	- 150,
	- false,
	- "Phoenix.Socket.V1.JSONSerializer"
	- ]
	- })
	-
	- assert binary ==
	- :erlang.term_to_binary(
	- {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	- )
	-
	- assert ConfigDB.from_binary(binary) ==
	- {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	+ assert ConfigDB.to_elixir_types(%{
	+ "tuple" => [
	+ "v1",
	+ ":v2",
	+ "Pleroma.Bookmark",
	+ 150,
	+ false,
	+ "Phoenix.Socket.V1.JSONSerializer"
	+ ]
	+ }) == {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
	end

	test "map with string key" do
	- binary = ConfigDB.transform(%{"key" => "value"})
	- assert binary == :erlang.term_to_binary(%{"key" => "value"})
	- assert ConfigDB.from_binary(binary) == %{"key" => "value"}
	+ assert ConfigDB.to_elixir_types(%{"key" => "value"}) == %{"key" => "value"}
	end

	test "map with atom key" do
	- binary = ConfigDB.transform(%{":key" => "value"})
	- assert binary == :erlang.term_to_binary(%{key: "value"})
	- assert ConfigDB.from_binary(binary) == %{key: "value"}
	+ assert ConfigDB.to_elixir_types(%{":key" => "value"}) == %{key: "value"}
	end

	test "list of strings" do
	- binary = ConfigDB.transform(["v1", "v2", "v3"])
	- assert binary == :erlang.term_to_binary(["v1", "v2", "v3"])
	- assert ConfigDB.from_binary(binary) == ["v1", "v2", "v3"]
	+ assert ConfigDB.to_elixir_types(["v1", "v2", "v3"]) == ["v1", "v2", "v3"]
	end

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

	test "list of atoms" do
	- binary = ConfigDB.transform([":v1", ":v2", ":v3"])
	- assert binary == :erlang.term_to_binary([:v1, :v2, :v3])
	- assert ConfigDB.from_binary(binary) == [:v1, :v2, :v3]
	+ assert ConfigDB.to_elixir_types([":v1", ":v2", ":v3"]) == [:v1, :v2, :v3]
	end

	test "list of mixed values" do
	- binary =
	- ConfigDB.transform([
	- "v1",
	- ":v2",
	- "Pleroma.Repo",
	- "Phoenix.Socket.V1.JSONSerializer",
	- 15,
	- false
	- ])
	-
	- assert binary ==
	- :erlang.term_to_binary([
	- "v1",
	- :v2,
	- Pleroma.Repo,
	- Phoenix.Socket.V1.JSONSerializer,
	- 15,
	- false
	- ])
	-
	- assert ConfigDB.from_binary(binary) == [
	+ assert ConfigDB.to_elixir_types([
	+ "v1",
	+ ":v2",
	+ "Pleroma.Repo",
	+ "Phoenix.Socket.V1.JSONSerializer",
	+ 15,
	+ false
	+ ]) == [
	"v1",
	:v2,
	Pleroma.Repo,
	Phoenix.Socket.V1.JSONSerializer,
	15,
	false
	]
	end

	test "simple keyword" do
	- binary = ConfigDB.transform([%{"tuple" => [":key", "value"]}])
	- assert binary == :erlang.term_to_binary([{:key, "value"}])
	- assert ConfigDB.from_binary(binary) == [{:key, "value"}]
	- assert ConfigDB.from_binary(binary) == [key: "value"]
	- end
	-
	- test "keyword with partial_chain key" do
	- binary =
	- ConfigDB.transform([%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}])
	-
	- assert binary == :erlang.term_to_binary(partial_chain: &:hackney_connect.partial_chain/1)
	- assert ConfigDB.from_binary(binary) == [partial_chain: &:hackney_connect.partial_chain/1]
	+ assert ConfigDB.to_elixir_types([%{"tuple" => [":key", "value"]}]) == [key: "value"]
	end

	test "keyword" do
	- binary =
	- ConfigDB.transform([
	- %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
	- %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
	- %{"tuple" => [":migration_lock", nil]},
	- %{"tuple" => [":key1", 150]},
	- %{"tuple" => [":key2", "string"]}
	- ])
	-
	- assert binary ==
	- :erlang.term_to_binary(
	- types: Pleroma.PostgresTypes,
	- telemetry_event: [Pleroma.Repo.Instrumenter],
	- migration_lock: nil,
	- key1: 150,
	- key2: "string"
	- )
	-
	- assert ConfigDB.from_binary(binary) == [
	+ assert ConfigDB.to_elixir_types([
	+ %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
	+ %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
	+ %{"tuple" => [":migration_lock", nil]},
	+ %{"tuple" => [":key1", 150]},
	+ %{"tuple" => [":key2", "string"]}
	+ ]) == [
	types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil,
	key1: 150,
	key2: "string"
	]
	end

	+ test "trandformed keyword" do
	+ assert ConfigDB.to_elixir_types(a: 1, b: 2, c: "string") == [a: 1, b: 2, c: "string"]
	+ end
	+
	test "complex keyword with nested mixed childs" do
	- binary =
	- ConfigDB.transform([
	- %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
	- %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
	- %{"tuple" => [":link_name", true]},
	- %{"tuple" => [":proxy_remote", false]},
	- %{"tuple" => [":common_map", %{":key" => "value"}]},
	- %{
	- "tuple" => [
	- ":proxy_opts",
	- [
	- %{"tuple" => [":redirect_on_failure", false]},
	- %{"tuple" => [":max_body_length", 1_048_576]},
	- %{
	- "tuple" => [
	- ":http",
	- [%{"tuple" => [":follow_redirect", true]}, %{"tuple" => [":pool", ":upload"]}]
	- ]
	- }
	- ]
	- ]
	- }
	- ])
	-
	- assert binary ==
	- :erlang.term_to_binary(
	- uploader: Pleroma.Uploaders.Local,
	- filters: [Pleroma.Upload.Filter.Dedupe],
	- link_name: true,
	- proxy_remote: false,
	- common_map: %{key: "value"},
	- proxy_opts: [
	- redirect_on_failure: false,
	- max_body_length: 1_048_576,
	- http: [
	- follow_redirect: true,
	- pool: :upload
	+ assert ConfigDB.to_elixir_types([
	+ %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
	+ %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
	+ %{"tuple" => [":link_name", true]},
	+ %{"tuple" => [":proxy_remote", false]},
	+ %{"tuple" => [":common_map", %{":key" => "value"}]},
	+ %{
	+ "tuple" => [
	+ ":proxy_opts",
	+ [
	+ %{"tuple" => [":redirect_on_failure", false]},
	+ %{"tuple" => [":max_body_length", 1_048_576]},
	+ %{
	+ "tuple" => [
	+ ":http",
	+ [
	+ %{"tuple" => [":follow_redirect", true]},
	+ %{"tuple" => [":pool", ":upload"]}
	+ ]
	+ ]
	+ }
	]
	]
	- )
	-
	- assert ConfigDB.from_binary(binary) ==
	- [
	- uploader: Pleroma.Uploaders.Local,
	- filters: [Pleroma.Upload.Filter.Dedupe],
	- link_name: true,
	- proxy_remote: false,
	- common_map: %{key: "value"},
	- proxy_opts: [
	- redirect_on_failure: false,
	- max_body_length: 1_048_576,
	- http: [
	- follow_redirect: true,
	- pool: :upload
	- ]
	+ }
	+ ]) == [
	+ uploader: Pleroma.Uploaders.Local,
	+ filters: [Pleroma.Upload.Filter.Dedupe],
	+ link_name: true,
	+ proxy_remote: false,
	+ common_map: %{key: "value"},
	+ proxy_opts: [
	+ redirect_on_failure: false,
	+ max_body_length: 1_048_576,
	+ http: [
	+ follow_redirect: true,
	+ pool: :upload
	]
	]
	+ ]
	end

	test "common keyword" do
	- binary =
	- ConfigDB.transform([
	- %{"tuple" => [":level", ":warn"]},
	- %{"tuple" => [":meta", [":all"]]},
	- %{"tuple" => [":path", ""]},
	- %{"tuple" => [":val", nil]},
	- %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
	- ])
	-
	- assert binary ==
	- :erlang.term_to_binary(
	- level: :warn,
	- meta: [:all],
	- path: "",
	- val: nil,
	- webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	- )
	-
	- assert ConfigDB.from_binary(binary) == [
	+ assert ConfigDB.to_elixir_types([
	+ %{"tuple" => [":level", ":warn"]},
	+ %{"tuple" => [":meta", [":all"]]},
	+ %{"tuple" => [":path", ""]},
	+ %{"tuple" => [":val", nil]},
	+ %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
	+ ]) == [
	level: :warn,
	meta: [:all],
	path: "",
	val: nil,
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	]
	end

	test "complex keyword with sigil" do
	- binary =
	- ConfigDB.transform([
	- %{"tuple" => [":federated_timeline_removal", []]},
	- %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
	- %{"tuple" => [":replace", []]}
	- ])
	-
	- assert binary ==
	- :erlang.term_to_binary(
	- federated_timeline_removal: [],
	- reject: [~r/comp[lL][aA][iI][nN]er/],
	- replace: []
	- )
	-
	- assert ConfigDB.from_binary(binary) ==
	- [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
	+ assert ConfigDB.to_elixir_types([
	+ %{"tuple" => [":federated_timeline_removal", []]},
	+ %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
	+ %{"tuple" => [":replace", []]}
	+ ]) == [
	+ federated_timeline_removal: [],
	+ reject: [~r/comp[lL][aA][iI][nN]er/],
	+ replace: []
	+ ]
	end

	test "complex keyword with tuples with more than 2 values" do
	- binary =
	- ConfigDB.transform([
	- %{
	- "tuple" => [
	- ":http",
	- [
	- %{
	- "tuple" => [
	- ":key1",
	- [
	- %{
	- "tuple" => [
	- ":_",
	- [
	- %{
	- "tuple" => [
	- "/api/v1/streaming",
	- "Pleroma.Web.MastodonAPI.WebsocketHandler",
	- []
	- ]
	- },
	- %{
	- "tuple" => [
	- "/websocket",
	- "Phoenix.Endpoint.CowboyWebSocket",
	- %{
	- "tuple" => [
	- "Phoenix.Transports.WebSocket",
	- %{
	- "tuple" => [
	- "Pleroma.Web.Endpoint",
	- "Pleroma.Web.UserSocket",
	- []
	- ]
	- }
	- ]
	- }
	- ]
	- },
	- %{
	- "tuple" => [
	- ":_",
	- "Phoenix.Endpoint.Cowboy2Handler",
	- %{"tuple" => ["Pleroma.Web.Endpoint", []]}
	- ]
	- }
	- ]
	- ]
	- }
	- ]
	- ]
	- }
	- ]
	- ]
	- }
	- ])
	-
	- assert binary ==
	- :erlang.term_to_binary(
	- http: [
	- key1: [
	- _: [
	- {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	- {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	- {Phoenix.Transports.WebSocket,
	- {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	- {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	- ]
	+ assert ConfigDB.to_elixir_types([
	+ %{
	+ "tuple" => [
	+ ":http",
	+ [
	+ %{
	+ "tuple" => [
	+ ":key1",
	+ [
	+ %{
	+ "tuple" => [
	+ ":_",
	+ [
	+ %{
	+ "tuple" => [
	+ "/api/v1/streaming",
	+ "Pleroma.Web.MastodonAPI.WebsocketHandler",
	+ []
	+ ]
	+ },
	+ %{
	+ "tuple" => [
	+ "/websocket",
	+ "Phoenix.Endpoint.CowboyWebSocket",
	+ %{
	+ "tuple" => [
	+ "Phoenix.Transports.WebSocket",
	+ %{
	+ "tuple" => [
	+ "Pleroma.Web.Endpoint",
	+ "Pleroma.Web.UserSocket",
	+ []
	+ ]
	+ }
	+ ]
	+ }
	+ ]
	+ },
	+ %{
	+ "tuple" => [
	+ ":_",
	+ "Phoenix.Endpoint.Cowboy2Handler",
	+ %{"tuple" => ["Pleroma.Web.Endpoint", []]}
	+ ]
	+ }
	+ ]
	+ ]
	+ }
	+ ]
	+ ]
	+ }
	]
	]
	- )
	-
	- assert ConfigDB.from_binary(binary) == [
	+ }
	+ ]) == [
	http: [
	key1: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	]
	]
	end
	end
	end
	diff --git a/test/config/transfer_task_test.exs b/test/config/transfer_task_test.exs
	index 473899d1d..f53829e09 100644
	--- a/test/config/transfer_task_test.exs
	+++ b/test/config/transfer_task_test.exs
	@@ -1,184 +1,120 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTaskTest do
	use Pleroma.DataCase

	import ExUnit.CaptureLog
	+ import Pleroma.Factory

	alias Pleroma.Config.TransferTask
	- alias Pleroma.ConfigDB

	setup do: clear_config(:configurable_from_database, true)

	test "transfer config values from db to env" do
	refute Application.get_env(:pleroma, :test_key)
	refute Application.get_env(:idna, :test_key)
	refute Application.get_env(:quack, :test_key)
	refute Application.get_env(:postgrex, :test_key)
	initial = Application.get_env(:logger, :level)

	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":test_key",
	- value: [live: 2, com: 3]
	- })
	-
	- ConfigDB.create(%{
	- group: ":idna",
	- key: ":test_key",
	- value: [live: 15, com: 35]
	- })
	-
	- ConfigDB.create(%{
	- group: ":quack",
	- key: ":test_key",
	- value: [:test_value1, :test_value2]
	- })
	-
	- ConfigDB.create(%{
	- group: ":postgrex",
	- key: ":test_key",
	- value: :value
	- })
	-
	- ConfigDB.create(%{group: ":logger", key: ":level", value: :debug})
	+ insert(:config, key: :test_key, value: [live: 2, com: 3])
	+ insert(:config, group: :idna, key: :test_key, value: [live: 15, com: 35])
	+ insert(:config, group: :quack, key: :test_key, value: [:test_value1, :test_value2])
	+ insert(:config, group: :postgrex, key: :test_key, value: :value)
	+ insert(:config, group: :logger, key: :level, value: :debug)

	TransferTask.start_link([])

	assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
	assert Application.get_env(:idna, :test_key) == [live: 15, com: 35]
	assert Application.get_env(:quack, :test_key) == [:test_value1, :test_value2]
	assert Application.get_env(:logger, :level) == :debug
	assert Application.get_env(:postgrex, :test_key) == :value

	on_exit(fn ->
	Application.delete_env(:pleroma, :test_key)
	Application.delete_env(:idna, :test_key)
	Application.delete_env(:quack, :test_key)
	Application.delete_env(:postgrex, :test_key)
	Application.put_env(:logger, :level, initial)
	end)
	end

	test "transfer config values for 1 group and some keys" do
	level = Application.get_env(:quack, :level)
	meta = Application.get_env(:quack, :meta)

	- ConfigDB.create(%{
	- group: ":quack",
	- key: ":level",
	- value: :info
	- })
	-
	- ConfigDB.create(%{
	- group: ":quack",
	- key: ":meta",
	- value: [:none]
	- })
	+ insert(:config, group: :quack, key: :level, value: :info)
	+ insert(:config, group: :quack, key: :meta, value: [:none])

	TransferTask.start_link([])

	assert Application.get_env(:quack, :level) == :info
	assert Application.get_env(:quack, :meta) == [:none]
	default = Pleroma.Config.Holder.default_config(:quack, :webhook_url)
	assert Application.get_env(:quack, :webhook_url) == default

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

	test "transfer config values with full subkey update" do
	clear_config(:emoji)
	clear_config(:assets)

	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":emoji",
	- value: [groups: [a: 1, b: 2]]
	- })
	-
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":assets",
	- value: [mascots: [a: 1, b: 2]]
	- })
	+ insert(:config, key: :emoji, value: [groups: [a: 1, b: 2]])
	+ insert(:config, key: :assets, value: [mascots: [a: 1, b: 2]])

	TransferTask.start_link([])

	emoji_env = Application.get_env(:pleroma, :emoji)
	assert emoji_env[:groups] == [a: 1, b: 2]
	assets_env = Application.get_env(:pleroma, :assets)
	assert assets_env[:mascots] == [a: 1, b: 2]
	end

	describe "pleroma restart" do
	setup do
	on_exit(fn -> Restarter.Pleroma.refresh() end)
	end

	test "don't restart if no reboot time settings were changed" do
	clear_config(:emoji)
	-
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":emoji",
	- value: [groups: [a: 1, b: 2]]
	- })
	+ insert(:config, key: :emoji, value: [groups: [a: 1, b: 2]])

	refute String.contains?(
	capture_log(fn -> TransferTask.start_link([]) end),
	"pleroma restarted"
	)
	end

	test "on reboot time key" do
	clear_config(:chat)
	-
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":chat",
	- value: [enabled: false]
	- })
	-
	+ insert(:config, key: :chat, value: [enabled: false])
	assert capture_log(fn -> TransferTask.start_link([]) end) =~ "pleroma restarted"
	end

	test "on reboot time subkey" do
	clear_config(Pleroma.Captcha)
	-
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: "Pleroma.Captcha",
	- value: [seconds_valid: 60]
	- })
	-
	+ insert(:config, key: Pleroma.Captcha, value: [seconds_valid: 60])
	assert capture_log(fn -> TransferTask.start_link([]) end) =~ "pleroma restarted"
	end

	test "don't restart pleroma on reboot time key and subkey if there is false flag" do
	clear_config(:chat)
	clear_config(Pleroma.Captcha)

	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":chat",
	- value: [enabled: false]
	- })
	-
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: "Pleroma.Captcha",
	- value: [seconds_valid: 60]
	- })
	+ insert(:config, key: :chat, value: [enabled: false])
	+ insert(:config, key: Pleroma.Captcha, value: [seconds_valid: 60])

	refute String.contains?(
	capture_log(fn -> TransferTask.load_and_update_env([], false) end),
	"pleroma restarted"
	)
	end
	end
	end
	diff --git a/test/support/factory.ex b/test/support/factory.ex
	index 6e3676aca..6e22b66a4 100644
	--- a/test/support/factory.ex
	+++ b/test/support/factory.ex
	@@ -1,436 +1,430 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

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

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

	def user_factory do
	user = %User{
	name: sequence(:name, &"Test テスト User #{&1}"),
	email: sequence(:email, &"user#{&1}@example.com"),
	nickname: sequence(:nickname, &"nick#{&1}"),
	password_hash: Pbkdf2.hash_pwd_salt("test"),
	bio: sequence(:bio, &"Tester Number #{&1}"),
	last_digest_emailed_at: NaiveDateTime.utc_now(),
	last_refreshed_at: NaiveDateTime.utc_now(),
	notification_settings: %Pleroma.User.NotificationSetting{},
	multi_factor_authentication_settings: %Pleroma.MFA.Settings{},
	ap_enabled: true
	}

	%{
	user
	\| ap_id: User.ap_id(user),
	follower_address: User.ap_followers(user),
	- following_address: User.ap_following(user)
	+ following_address: User.ap_following(user),
	+ raw_bio: user.bio
	}
	end

	def user_relationship_factory(attrs \\ %{}) do
	source = attrs[:source] \|\| insert(:user)
	target = attrs[:target] \|\| insert(:user)
	relationship_type = attrs[:relationship_type] \|\| :block

	%Pleroma.UserRelationship{
	source_id: source.id,
	target_id: target.id,
	relationship_type: relationship_type
	}
	end

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

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

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

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

	def audio_factory(attrs \\ %{}) do
	text = sequence(:text, &"lain radio episode #{&1}")

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

	data = %{
	"type" => "Audio",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"artist" => "lain",
	"title" => text,
	"album" => "lain radio",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"actor" => user.ap_id,
	"length" => 180_000
	}

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

	def listen_factory do
	audio = insert(:audio)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Listen",
	"actor" => audio.data["actor"],
	"to" => audio.data["to"],
	"object" => audio.data,
	"published" => audio.data["published"]
	}

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

	def direct_note_factory do
	user2 = insert(:user)

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

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

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

	%Pleroma.Object{
	data: data
	}
	end

	def direct_note_activity_factory do
	dm = insert(:direct_note)

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

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

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

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

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

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	defp expiration_offset_by_minutes(attrs, minutes) do
	scheduled_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(minutes), :millisecond)
	\|> NaiveDateTime.truncate(:second)

	%Pleroma.ActivityExpiration{}
	\|> Map.merge(attrs)
	\|> Map.put(:scheduled_at, scheduled_at)
	end

	def expiration_in_the_past_factory(attrs \\ %{}) do
	expiration_offset_by_minutes(attrs, -60)
	end

	def expiration_in_the_future_factory(attrs \\ %{}) do
	expiration_offset_by_minutes(attrs, 61)
	end

	def article_activity_factory do
	article = insert(:article)

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

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

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

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

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

	def like_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

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

	%Pleroma.Activity{
	data: data
	}
	end

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

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

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

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

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

	def oauth_token_factory(attrs \\ %{}) do
	scopes = Map.get(attrs, :scopes, ["read"])
	oauth_app = Map.get_lazy(attrs, :app, fn -> insert(:oauth_app, scopes: scopes) end)
	user = Map.get_lazy(attrs, :user, fn -> build(:user) end)

	valid_until =
	Map.get(attrs, :valid_until, NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10))

	%Pleroma.Web.OAuth.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	refresh_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	scopes: scopes,
	user: user,
	app: oauth_app,
	valid_until: valid_until
	}
	end

	def oauth_admin_token_factory(attrs \\ %{}) do
	user = Map.get_lazy(attrs, :user, fn -> build(:user, is_admin: true) end)

	scopes =
	attrs
	\|> Map.get(:scopes, ["admin"])
	\|> Kernel.++(["admin"])
	\|> Enum.uniq()

	attrs = Map.merge(attrs, %{user: user, scopes: scopes})
	oauth_token_factory(attrs)
	end

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

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

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

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

	def registration_factory do
	user = insert(:user)

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

	- def config_factory do
	+ def config_factory(attrs \\ %{}) do
	%Pleroma.ConfigDB{
	- key:
	- sequence(:key, fn key ->
	- # Atom dynamic registration hack in tests
	- "some_key_#{key}"
	- \|> String.to_atom()
	- \|> inspect()
	- end),
	- group: ":pleroma",
	+ key: sequence(:key, &String.to_atom("some_key_#{&1}")),
	+ group: :pleroma,
	value:
	sequence(
	:value,
	- fn key ->
	- :erlang.term_to_binary(%{another_key: "#{key}somevalue", another: "#{key}somevalue"})
	- end
	+ &%{another_key: "#{&1}somevalue", another: "#{&1}somevalue"}
	)
	}
	+ \|> merge_attributes(attrs)
	end

	def marker_factory do
	%Pleroma.Marker{
	user: build(:user),
	timeline: "notifications",
	lock_version: 0,
	last_read_id: "1"
	}
	end

	def mfa_token_factory do
	%Pleroma.MFA.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	authorization: build(:oauth_authorization),
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user)
	}
	end
	end
	diff --git a/test/tasks/config_test.exs b/test/tasks/config_test.exs
	index 04bc947a9..e1bddfebf 100644
	--- a/test/tasks/config_test.exs
	+++ b/test/tasks/config_test.exs
	@@ -1,195 +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.ConfigTest do
	use Pleroma.DataCase

	+ import Pleroma.Factory
	+
	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	Application.delete_env(:pleroma, :first_setting)
	Application.delete_env(:pleroma, :second_setting)
	end)

	:ok
	end

	setup_all do: clear_config(:configurable_from_database, true)

	test "error if file with custom settings doesn't exist" do
	Mix.Tasks.Pleroma.Config.migrate_to_db("config/not_existance_config_file.exs")

	assert_receive {:mix_shell, :info,
	[
	"To migrate settings, you must define custom settings in config/not_existance_config_file.exs."
	]},
	15
	end

	describe "migrate_to_db/1" do
	setup do
	initial = Application.get_env(:quack, :level)
	on_exit(fn -> Application.put_env(:quack, :level, initial) end)
	end

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

	Mix.Tasks.Pleroma.Config.migrate_to_db("test/fixtures/config/temp.secret.exs")

	config1 = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
	config2 = ConfigDB.get_by_params(%{group: ":pleroma", key: ":second_setting"})
	config3 = ConfigDB.get_by_params(%{group: ":quack", key: ":level"})
	refute ConfigDB.get_by_params(%{group: ":pleroma", key: "Pleroma.Repo"})
	refute ConfigDB.get_by_params(%{group: ":postgrex", key: ":json_library"})

	- assert ConfigDB.from_binary(config1.value) == [key: "value", key2: [Repo]]
	- assert ConfigDB.from_binary(config2.value) == [key: "value2", key2: ["Activity"]]
	- assert ConfigDB.from_binary(config3.value) == :info
	+ assert config1.value == [key: "value", key2: [Repo]]
	+ assert config2.value == [key: "value2", key2: ["Activity"]]
	+ assert config3.value == :info
	end

	test "config table is truncated before migration" do
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":first_setting",
	- value: [key: "value", key2: ["Activity"]]
	- })
	-
	+ insert(:config, key: :first_setting, value: [key: "value", key2: ["Activity"]])
	assert Repo.aggregate(ConfigDB, :count, :id) == 1

	Mix.Tasks.Pleroma.Config.migrate_to_db("test/fixtures/config/temp.secret.exs")

	config = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
	- assert ConfigDB.from_binary(config.value) == [key: "value", key2: [Repo]]
	+ assert config.value == [key: "value", key2: [Repo]]
	end
	end

	describe "with deletion temp file" do
	setup do
	temp_file = "config/temp.exported_from_db.secret.exs"

	on_exit(fn ->
	:ok = File.rm(temp_file)
	end)

	{:ok, temp_file: temp_file}
	end

	test "settings are migrated to file and deleted from db", %{temp_file: temp_file} do
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":setting_first",
	- value: [key: "value", key2: ["Activity"]]
	- })
	-
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":setting_second",
	- value: [key: "value2", key2: [Repo]]
	- })
	-
	- ConfigDB.create(%{group: ":quack", key: ":level", value: :info})
	+ insert(:config, key: :setting_first, value: [key: "value", key2: ["Activity"]])
	+ insert(:config, key: :setting_second, value: [key: "value2", key2: [Repo]])
	+ insert(:config, group: :quack, key: :level, value: :info)

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

	assert Repo.all(ConfigDB) == []

	file = File.read!(temp_file)
	assert file =~ "config :pleroma, :setting_first,"
	assert file =~ "config :pleroma, :setting_second,"
	assert file =~ "config :quack, :level, :info"
	end

	test "load a settings with large values and pass to file", %{temp_file: temp_file} do
	- ConfigDB.create(%{
	- group: ":pleroma",
	- key: ":instance",
	+ insert(:config,
	+ key: :instance,
	value: [
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	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,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	federation_publisher_modules: [Pleroma.Web.ActivityPub.Publisher],
	allow_relay: true,
	rewrite_policy: Pleroma.Web.ActivityPub.MRF.NoOpPolicy,
	public: true,
	quarantined_instances: [],
	managed_config: true,
	static_dir: "instance/static/",
	allowed_post_formats: ["text/plain", "text/html", "text/markdown", "text/bbcode"],
	mrf_transparency: true,
	mrf_transparency_exclusions: [],
	autofollowed_nicknames: [],
	max_pinned_statuses: 1,
	attachment_links: false,
	welcome_user_nickname: nil,
	welcome_message: nil,
	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,
	external_user_synchronization: true,
	extended_nickname_format: true,
	multi_factor_authentication: [
	totp: [
	- # digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]
	]
	- })
	+ )

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

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

	header =
	if Code.ensure_loaded?(Config.Reader) do
	"import Config"
	else
	"use Mix.Config"
	end

	assert file ==
	"#{header}\n\nconfig :pleroma, :instance,\n name: \"Pleroma\",\n email: \"example@example.com\",\n notify_email: \"noreply@example.com\",\n description: \"A Pleroma instance, an alternative fediverse server\",\n limit: 5000,\n chat_limit: 5000,\n remote_limit: 100_000,\n upload_limit: 16_000_000,\n avatar_upload_limit: 2_000_000,\n background_upload_limit: 4_000_000,\n banner_upload_limit: 4_000_000,\n poll_limits: %{\n max_expiration: 31_536_000,\n max_option_chars: 200,\n max_options: 20,\n min_expiration: 0\n },\n registrations_open: true,\n federating: true,\n federation_incoming_replies_max_depth: 100,\n federation_reachability_timeout_days: 7,\n federation_publisher_modules: [Pleroma.Web.ActivityPub.Publisher],\n allow_relay: true,\n rewrite_policy: Pleroma.Web.ActivityPub.MRF.NoOpPolicy,\n public: true,\n quarantined_instances: [],\n managed_config: true,\n static_dir: \"instance/static/\",\n allowed_post_formats: [\"text/plain\", \"text/html\", \"text/markdown\", \"text/bbcode\"],\n mrf_transparency: true,\n mrf_transparency_exclusions: [],\n autofollowed_nicknames: [],\n max_pinned_statuses: 1,\n attachment_links: false,\n welcome_user_nickname: nil,\n welcome_message: nil,\n max_report_comment_size: 1000,\n safe_dm_mentions: false,\n healthcheck: false,\n remote_post_retention_days: 90,\n skip_thread_containment: true,\n limit_to_local_content: :unauthenticated,\n user_bio_length: 5000,\n user_name_length: 100,\n max_account_fields: 10,\n max_remote_account_fields: 20,\n account_field_name_length: 512,\n account_field_value_length: 2048,\n external_user_synchronization: true,\n extended_nickname_format: true,\n multi_factor_authentication: [\n totp: [digits: 6, period: 30],\n backup_codes: [number: 2, length: 6]\n ]\n"
	end
	end
	end
	diff --git a/test/upload/filter/mogrify_test.exs b/test/upload/filter/mogrify_test.exs
	index b6a463e8c..62ca30487 100644
	--- a/test/upload/filter/mogrify_test.exs
	+++ b/test/upload/filter/mogrify_test.exs
	@@ -1,45 +1,41 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Upload.Filter.MogrifyTest do
	use Pleroma.DataCase
	import Mock

	- alias Pleroma.Config
	- alias Pleroma.Upload
	alias Pleroma.Upload.Filter

	- setup do: clear_config([Filter.Mogrify, :args])
	-
	test "apply mogrify filter" do
	- Config.put([Filter.Mogrify, :args], [{"tint", "40"}])
	+ clear_config(Filter.Mogrify, args: [{"tint", "40"}])

	File.cp!(
	"test/fixtures/image.jpg",
	"test/fixtures/image_tmp.jpg"
	)

	- upload = %Upload{
	+ upload = %Pleroma.Upload{
	name: "an… image.jpg",
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image_tmp.jpg"),
	tempfile: Path.absname("test/fixtures/image_tmp.jpg")
	}

	task =
	Task.async(fn ->
	assert_receive {:apply_filter, {_, "tint", "40"}}, 4_000
	end)

	with_mock Mogrify,
	open: fn _f -> %Mogrify.Image{} end,
	custom: fn _m, _a -> :ok end,
	custom: fn m, a, o -> send(task.pid, {:apply_filter, {m, a, o}}) end,
	save: fn _f, _o -> :ok end do
	assert Filter.Mogrify.filter(upload) == :ok
	end

	Task.await(task)
	end
	end
	diff --git a/test/web/activity_pub/object_validators/types/date_time_test.exs b/test/web/activity_pub/object_validators/types/date_time_test.exs
	index 3e17a9497..43be8e936 100644
	--- a/test/web/activity_pub/object_validators/types/date_time_test.exs
	+++ b/test/web/activity_pub/object_validators/types/date_time_test.exs
	@@ -1,32 +1,32 @@
	defmodule Pleroma.Web.ActivityPub.ObjectValidators.Types.DateTimeTest do
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types.DateTime
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators.DateTime
	use Pleroma.DataCase

	test "it validates an xsd:Datetime" do
	valid_strings = [
	"2004-04-12T13:20:00",
	"2004-04-12T13:20:15.5",
	"2004-04-12T13:20:00-05:00",
	"2004-04-12T13:20:00Z"
	]

	invalid_strings = [
	"2004-04-12T13:00",
	"2004-04-1213:20:00",
	"99-04-12T13:00",
	"2004-04-12"
	]

	assert {:ok, "2004-04-01T12:00:00Z"} == DateTime.cast("2004-04-01T12:00:00Z")

	Enum.each(valid_strings, fn date_time ->
	result = DateTime.cast(date_time)
	assert {:ok, _} = result
	end)

	Enum.each(invalid_strings, fn date_time ->
	result = DateTime.cast(date_time)
	assert :error == result
	end)
	end
	end
	diff --git a/test/web/activity_pub/object_validators/types/object_id_test.exs b/test/web/activity_pub/object_validators/types/object_id_test.exs
	index c8911948e..e0ab76379 100644
	--- a/test/web/activity_pub/object_validators/types/object_id_test.exs
	+++ b/test/web/activity_pub/object_validators/types/object_id_test.exs
	@@ -1,41 +1,41 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ObjectValidators.Types.ObjectIDTest do
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types.ObjectID
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators.ObjectID
	use Pleroma.DataCase

	@uris [
	"http://lain.com/users/lain",
	"http://lain.com",
	"https://lain.com/object/1"
	]

	@non_uris [
	"https://",
	"rin",
	1,
	:x,
	%{"1" => 2}
	]

	test "it accepts http uris" do
	Enum.each(@uris, fn uri ->
	assert {:ok, uri} == ObjectID.cast(uri)
	end)
	end

	test "it accepts an object with a nested uri id" do
	Enum.each(@uris, fn uri ->
	assert {:ok, uri} == ObjectID.cast(%{"id" => uri})
	end)
	end

	test "it rejects non-uri strings" do
	Enum.each(@non_uris, fn non_uri ->
	assert :error == ObjectID.cast(non_uri)
	assert :error == ObjectID.cast(%{"id" => non_uri})
	end)
	end
	end
	diff --git a/test/web/activity_pub/object_validators/types/recipients_test.exs b/test/web/activity_pub/object_validators/types/recipients_test.exs
	index f278f039b..053916bdd 100644
	--- a/test/web/activity_pub/object_validators/types/recipients_test.exs
	+++ b/test/web/activity_pub/object_validators/types/recipients_test.exs
	@@ -1,27 +1,27 @@
	defmodule Pleroma.Web.ObjectValidators.Types.RecipientsTest do
	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types.Recipients
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators.Recipients
	use Pleroma.DataCase

	test "it asserts that all elements of the list are object ids" do
	list = ["https://lain.com/users/lain", "invalid"]

	assert :error == Recipients.cast(list)
	end

	test "it works with a list" do
	list = ["https://lain.com/users/lain"]
	assert {:ok, list} == Recipients.cast(list)
	end

	test "it works with a list with whole objects" do
	list = ["https://lain.com/users/lain", %{"id" => "https://gensokyo.2hu/users/raymoo"}]
	resulting_list = ["https://gensokyo.2hu/users/raymoo", "https://lain.com/users/lain"]
	assert {:ok, resulting_list} == Recipients.cast(list)
	end

	test "it turns a single string into a list" do
	recipient = "https://lain.com/users/lain"

	assert {:ok, [recipient]} == Recipients.cast(recipient)
	end
	end
	diff --git a/test/web/activity_pub/object_validators/types/safe_text_test.exs b/test/web/activity_pub/object_validators/types/safe_text_test.exs
	index d4a574554..9c08606f6 100644
	--- a/test/web/activity_pub/object_validators/types/safe_text_test.exs
	+++ b/test/web/activity_pub/object_validators/types/safe_text_test.exs
	@@ -1,30 +1,30 @@
	# 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.ObjectValidators.Types.SafeTextTest do
	use Pleroma.DataCase

	- alias Pleroma.Web.ActivityPub.ObjectValidators.Types.SafeText
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators.SafeText

	test "it lets normal text go through" do
	text = "hey how are you"
	assert {:ok, text} == SafeText.cast(text)
	end

	test "it removes html tags from text" do
	text = "hey look xss <script>alert('foo')</script>"
	assert {:ok, "hey look xss alert('foo')"} == SafeText.cast(text)
	end

	test "it keeps basic html tags" do
	text = "hey <a href='http://gensokyo.2hu'>look</a> xss <script>alert('foo')</script>"

	assert {:ok, "hey <a href=\"http://gensokyo.2hu\">look</a> xss alert('foo')"} ==
	SafeText.cast(text)
	end

	test "errors for non-text" do
	assert :error == SafeText.cast(1)
	end
	end
	diff --git a/test/web/admin_api/controllers/config_controller_test.exs b/test/web/admin_api/controllers/config_controller_test.exs
	index 780de8d18..064ef9bc7 100644
	--- a/test/web/admin_api/controllers/config_controller_test.exs
	+++ b/test/web/admin_api/controllers/config_controller_test.exs
	@@ -1,1290 +1,1388 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	import ExUnit.CaptureLog
	import Pleroma.Factory

	alias Pleroma.Config
	alias Pleroma.ConfigDB

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	config3 =
	insert(:config,
	- value: ConfigDB.to_binary(k1: :v1, k2: :v2)
	+ value: [k1: :v1, k2: :v2]
	)

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

	assert length(configs) > 3

	+ saved_configs = [config1, config2, config3]
	+ keys = Enum.map(saved_configs, &inspect(&1.key))
	+
	received_configs =
	Enum.filter(configs, fn %{"group" => group, "key" => key} ->
	- group == ":pleroma" and key in [config1.key, config2.key, config3.key]
	+ group == ":pleroma" and key in keys
	end)

	assert length(received_configs) == 3

	db_keys =
	config3.value
	- \|> ConfigDB.from_binary()
	\|> Keyword.keys()
	- \|> ConfigDB.convert()
	+ \|> ConfigDB.to_json_types()
	+
	+ keys = Enum.map(saved_configs -- [config3], &inspect(&1.key))
	+
	+ values = Enum.map(saved_configs, &ConfigDB.to_json_types(&1.value))
	+
	+ mapset_keys = MapSet.new(keys ++ db_keys)

	Enum.each(received_configs, fn %{"value" => value, "db" => db} ->
	- assert db in [[config1.key], [config2.key], db_keys]
	+ db = MapSet.new(db)
	+ assert MapSet.subset?(db, mapset_keys)

	- assert value in [
	- ConfigDB.from_binary_with_convert(config1.value),
	- ConfigDB.from_binary_with_convert(config2.value),
	- ConfigDB.from_binary_with_convert(config3.value)
	- ]
	+ assert value in values
	end)
	end

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

	- config2 =
	- insert(:config,
	- key: ":assets",
	- value: ConfigDB.to_binary(mascots: [a: 1, b: 2], key: [a: 1])
	- )
	+ insert(:config,
	+ key: ":assets",
	+ value: [mascots: [a: 1, b: 2], key: [a: 1]]
	+ )

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

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

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

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

	assert emoji_val[:groups] == [a: 1, b: 2]
	assert assets_val[:mascots] == [a: 1, b: 2]
	end
	end

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

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

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

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

	setup do: clear_config(:configurable_from_database, true)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert configs["need_reboot"]

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

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

	assert configs["need_reboot"] == false
	end

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

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

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

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

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

	assert configs["need_reboot"] == false
	end

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

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

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

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

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

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

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

	- config =
	- insert(:config,
	- group: ":logger",
	- key: ":backends",
	- value: :erlang.term_to_binary([])
	- )
	+ insert(:config,
	+ group: :logger,
	+ key: :backends,
	+ value: []
	+ )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	assert Application.get_env(:pleroma, :key1) == "value1"
	assert Application.get_env(:pleroma, :key2) == "value2"
	assert Application.get_env(:pleroma, :key3) == nil
	assert Application.get_env(:pleroma, Pleroma.Web.Endpoint.NotReal) == nil
	assert Application.get_env(:pleroma, Pleroma.Captcha.NotReal) == "value5"
	assert Application.get_env(:not_real, :anything) == "value6"
	end
	+
	+ test "args for Pleroma.Upload.Filter.Mogrify with custom tuples", %{conn: conn} do
	+ clear_config(Pleroma.Upload.Filter.Mogrify)
	+
	+ assert conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> post("/api/pleroma/admin/config", %{
	+ configs: [
	+ %{
	+ group: ":pleroma",
	+ key: "Pleroma.Upload.Filter.Mogrify",
	+ value: [
	+ %{"tuple" => [":args", ["auto-orient", "strip"]]}
	+ ]
	+ }
	+ ]
	+ })
	+ \|> json_response_and_validate_schema(200) == %{
	+ "configs" => [
	+ %{
	+ "group" => ":pleroma",
	+ "key" => "Pleroma.Upload.Filter.Mogrify",
	+ "value" => [
	+ %{"tuple" => [":args", ["auto-orient", "strip"]]}
	+ ],
	+ "db" => [":args"]
	+ }
	+ ],
	+ "need_reboot" => false
	+ }
	+
	+ assert Config.get(Pleroma.Upload.Filter.Mogrify) == [args: ["auto-orient", "strip"]]
	+
	+ assert conn
	+ \|> put_req_header("content-type", "application/json")
	+ \|> post("/api/pleroma/admin/config", %{
	+ configs: [
	+ %{
	+ group: ":pleroma",
	+ key: "Pleroma.Upload.Filter.Mogrify",
	+ value: [
	+ %{
	+ "tuple" => [
	+ ":args",
	+ [
	+ "auto-orient",
	+ "strip",
	+ "{\"implode\", \"1\"}",
	+ "{\"resize\", \"3840x1080>\"}"
	+ ]
	+ ]
	+ }
	+ ]
	+ }
	+ ]
	+ })
	+ \|> json_response(200) == %{
	+ "configs" => [
	+ %{
	+ "group" => ":pleroma",
	+ "key" => "Pleroma.Upload.Filter.Mogrify",
	+ "value" => [
	+ %{
	+ "tuple" => [
	+ ":args",
	+ [
	+ "auto-orient",
	+ "strip",
	+ "{\"implode\", \"1\"}",
	+ "{\"resize\", \"3840x1080>\"}"
	+ ]
	+ ]
	+ }
	+ ],
	+ "db" => [":args"]
	+ }
	+ ],
	+ "need_reboot" => false
	+ }
	+
	+ assert Config.get(Pleroma.Upload.Filter.Mogrify) == [
	+ args: ["auto-orient", "strip", {"implode", "1"}, {"resize", "3840x1080>"}]
	+ ]
	+ end
	end

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

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

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

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

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

	admin = insert(:user, is_admin: true)

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

	children = json_response_and_validate_schema(conn, 200)

	assert length(children) == 4

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

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

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

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

	esshd = Enum.find(children, fn c -> c["group"] == ":esshd" end)
	assert esshd["children"]
	end
	end
	end
	diff --git a/test/web/mastodon_api/controllers/account_controller/update_credentials_test.exs b/test/web/mastodon_api/controllers/account_controller/update_credentials_test.exs
	index 7c420985d..76e6d603a 100644
	--- a/test/web/mastodon_api/controllers/account_controller/update_credentials_test.exs
	+++ b/test/web/mastodon_api/controllers/account_controller/update_credentials_test.exs
	@@ -1,398 +1,403 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.MastodonAPIController.UpdateCredentialsTest do
	alias Pleroma.Repo
	alias Pleroma.User

	use Pleroma.Web.ConnCase

	import Mock
	import Pleroma.Factory

	setup do: clear_config([:instance, :max_account_fields])

	describe "updating credentials" do
	setup do: oauth_access(["write:accounts"])
	setup :request_content_type

	test "sets user settings in a generic way", %{conn: conn} do
	res_conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	pleroma_fe: %{
	theme: "bla"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)
	assert user_data["pleroma"]["settings_store"] == %{"pleroma_fe" => %{"theme" => "bla"}}

	user = Repo.get(User, user_data["id"])

	res_conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	masto_fe: %{
	theme: "bla"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)

	assert user_data["pleroma"]["settings_store"] ==
	%{
	"pleroma_fe" => %{"theme" => "bla"},
	"masto_fe" => %{"theme" => "bla"}
	}

	user = Repo.get(User, user_data["id"])

	clear_config([:instance, :federating], true)

	with_mock Pleroma.Web.Federator,
	publish: fn _activity -> :ok end do
	res_conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"pleroma_settings_store" => %{
	masto_fe: %{
	theme: "blub"
	}
	}
	})

	assert user_data = json_response_and_validate_schema(res_conn, 200)

	assert user_data["pleroma"]["settings_store"] ==
	%{
	"pleroma_fe" => %{"theme" => "bla"},
	"masto_fe" => %{"theme" => "blub"}
	}

	assert_called(Pleroma.Web.Federator.publish(:_))
	end
	end

	test "updates the user's bio", %{conn: conn} do
	user2 = insert(:user)

	- conn =
	- patch(conn, "/api/v1/accounts/update_credentials", %{
	- "note" => "I drink #cofe with @#{user2.nickname}\n\nsuya.."
	- })
	+ raw_bio = "I drink #cofe with @#{user2.nickname}\n\nsuya.."
	+
	+ conn = patch(conn, "/api/v1/accounts/update_credentials", %{"note" => raw_bio})

	assert user_data = json_response_and_validate_schema(conn, 200)

	assert user_data["note"] ==
	~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe">#cofe</a> with <span class="h-card"><a class="u-url mention" data-user="#{
	user2.id
	}" href="#{user2.ap_id}" rel="ugc">@<span>#{user2.nickname}</span></a></span><br/><br/>suya..)
	+
	+ assert user_data["source"]["note"] == raw_bio
	+
	+ user = Repo.get(User, user_data["id"])
	+
	+ assert user.raw_bio == raw_bio
	end

	test "updates the user's locking status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["locked"] == true
	end

	test "updates the user's allow_following_move", %{user: user, conn: conn} do
	assert user.allow_following_move == true

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{allow_following_move: "false"})

	assert refresh_record(user).allow_following_move == false
	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["allow_following_move"] == false
	end

	test "updates the user's default scope", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{default_scope: "unlisted"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["privacy"] == "unlisted"
	end

	test "updates the user's privacy", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{source: %{privacy: "unlisted"}})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["privacy"] == "unlisted"
	end

	test "updates the user's hide_followers status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_followers: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_followers"] == true
	end

	test "updates the user's discoverable status", %{conn: conn} do
	assert %{"source" => %{"pleroma" => %{"discoverable" => true}}} =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{discoverable: "true"})
	\|> json_response_and_validate_schema(:ok)

	assert %{"source" => %{"pleroma" => %{"discoverable" => false}}} =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{discoverable: "false"})
	\|> json_response_and_validate_schema(:ok)
	end

	test "updates the user's hide_followers_count and hide_follows_count", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	hide_followers_count: "true",
	hide_follows_count: "true"
	})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_followers_count"] == true
	assert user_data["pleroma"]["hide_follows_count"] == true
	end

	test "updates the user's skip_thread_containment option", %{user: user, conn: conn} do
	response =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{skip_thread_containment: "true"})
	\|> json_response_and_validate_schema(200)

	assert response["pleroma"]["skip_thread_containment"] == true
	assert refresh_record(user).skip_thread_containment
	end

	test "updates the user's hide_follows status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_follows: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_follows"] == true
	end

	test "updates the user's hide_favorites status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{hide_favorites: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["pleroma"]["hide_favorites"] == true
	end

	test "updates the user's show_role status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{show_role: "false"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["pleroma"]["show_role"] == false
	end

	test "updates the user's no_rich_text status", %{conn: conn} do
	conn = patch(conn, "/api/v1/accounts/update_credentials", %{no_rich_text: "true"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["source"]["pleroma"]["no_rich_text"] == true
	end

	test "updates the user's name", %{conn: conn} do
	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user_data = json_response_and_validate_schema(conn, 200)
	assert user_data["display_name"] == "markorepairs"
	end

	test "updates the user's avatar", %{user: user, conn: conn} do
	new_avatar = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response_and_validate_schema(conn, 200)
	assert user_response["avatar"] != User.avatar_url(user)
	end

	test "updates the user's banner", %{user: user, conn: conn} do
	new_header = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn = patch(conn, "/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response_and_validate_schema(conn, 200)
	assert user_response["header"] != User.banner_url(user)
	end

	test "updates the user's background", %{conn: conn} do
	new_header = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"pleroma_background_image" => new_header
	})

	assert user_response = json_response_and_validate_schema(conn, 200)
	assert user_response["pleroma"]["background_image"]
	end

	test "requires 'write:accounts' permission" do
	token1 = insert(:oauth_token, scopes: ["read"])
	token2 = insert(:oauth_token, scopes: ["write", "follow"])

	for token <- [token1, token2] do
	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> patch("/api/v1/accounts/update_credentials", %{})

	if token == token1 do
	assert %{"error" => "Insufficient permissions: write:accounts."} ==
	json_response_and_validate_schema(conn, 403)
	else
	assert json_response_and_validate_schema(conn, 200)
	end
	end
	end

	test "updates profile emojos", %{user: user, conn: conn} do
	note = "sips :blank:"
	name = "I am :firefox:"

	ret_conn =
	patch(conn, "/api/v1/accounts/update_credentials", %{
	"note" => note,
	"display_name" => name
	})

	assert json_response_and_validate_schema(ret_conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}")

	assert user_data = json_response_and_validate_schema(conn, 200)

	assert user_data["note"] == note
	assert user_data["display_name"] == name
	assert [%{"shortcode" => "blank"}, %{"shortcode" => "firefox"}] = user_data["emojis"]
	end

	test "update fields", %{conn: conn} do
	fields = [
	%{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "<script>bar</script>"},
	%{"name" => "link.io", "value" => "cofe.io"}
	]

	account_data =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(200)

	assert account_data["fields"] == [
	%{"name" => "<a href=\"http://google.com\">foo</a>", "value" => "bar"},
	%{
	"name" => "link.io",
	"value" => ~S(<a href="http://cofe.io" rel="ugc">cofe.io</a>)
	}
	]

	assert account_data["source"]["fields"] == [
	%{
	"name" => "<a href=\"http://google.com\">foo</a>",
	"value" => "<script>bar</script>"
	},
	%{"name" => "link.io", "value" => "cofe.io"}
	]
	end

	test "update fields via x-www-form-urlencoded", %{conn: conn} do
	fields =
	[
	"fields_attributes[1][name]=link",
	"fields_attributes[1][value]=http://cofe.io",
	"fields_attributes[0][name]=foo",
	"fields_attributes[0][value]=bar"
	]
	\|> Enum.join("&")

	account =
	conn
	\|> put_req_header("content-type", "application/x-www-form-urlencoded")
	\|> patch("/api/v1/accounts/update_credentials", fields)
	\|> json_response_and_validate_schema(200)

	assert account["fields"] == [
	%{"name" => "foo", "value" => "bar"},
	%{
	"name" => "link",
	"value" => ~S(<a href="http://cofe.io" rel="ugc">http://cofe.io</a>)
	}
	]

	assert account["source"]["fields"] == [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "link", "value" => "http://cofe.io"}
	]
	end

	test "update fields with empty name", %{conn: conn} do
	fields = [
	%{"name" => "foo", "value" => ""},
	%{"name" => "", "value" => "bar"}
	]

	account =
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(200)

	assert account["fields"] == [
	%{"name" => "foo", "value" => ""}
	]
	end

	test "update fields when invalid request", %{conn: conn} do
	name_limit = Pleroma.Config.get([:instance, :account_field_name_length])
	value_limit = Pleroma.Config.get([:instance, :account_field_value_length])

	long_name = Enum.map(0..name_limit, fn _ -> "x" end) \|> Enum.join()
	long_value = Enum.map(0..value_limit, fn _ -> "x" end) \|> Enum.join()

	fields = [%{"name" => "foo", "value" => long_value}]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)

	fields = [%{"name" => long_name, "value" => "bar"}]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)

	Pleroma.Config.put([:instance, :max_account_fields], 1)

	fields = [
	%{"name" => "foo", "value" => "bar"},
	%{"name" => "link", "value" => "cofe.io"}
	]

	assert %{"error" => "Invalid request"} ==
	conn
	\|> patch("/api/v1/accounts/update_credentials", %{"fields_attributes" => fields})
	\|> json_response_and_validate_schema(403)
	end
	end
	end
	diff --git a/test/web/mastodon_api/views/account_view_test.exs b/test/web/mastodon_api/views/account_view_test.exs
	index 044f088a4..80b1f734c 100644
	--- a/test/web/mastodon_api/views/account_view_test.exs
	+++ b/test/web/mastodon_api/views/account_view_test.exs
	@@ -1,523 +1,524 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
	use Pleroma.DataCase

	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView

	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "Represent a user account" do
	background_image = %{
	"url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
	}

	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	background: background_image,
	nickname: "shp@shitposter.club",
	name: ":karjalanpiirakka: shp",
	bio:
	"<script src=\"invalid-html\"></script><span>valid html</span>. a<br>b<br/>c<br >d<br />f '&<>\"",
	inserted_at: ~N[2017-08-15 15:47:06.597036],
	- emoji: %{"karjalanpiirakka" => "/file.png"}
	+ emoji: %{"karjalanpiirakka" => "/file.png"},
	+ raw_bio: "valid html. a\nb\nc\nd\nf '&<>\""
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: "<span>valid html</span>. a<br/>b<br/>c<br/>d<br/>f '&<>"",
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [
	%{
	static_url: "/file.png",
	url: "/file.png",
	shortcode: "karjalanpiirakka",
	visible_in_picker: false
	}
	],
	fields: [],
	bot: false,
	source: %{
	note: "valid html. a\nb\nc\nd\nf '&<>\"",
	sensitive: false,
	pleroma: %{
	actor_type: "Person",
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	ap_id: user.ap_id,
	background_image: "https://example.com/images/asuka_hospital.png",
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user})
	end

	test "Represent the user account for the account owner" do
	user = insert(:user)

	notification_settings = %{
	followers: true,
	follows: true,
	non_followers: true,
	non_follows: true,
	privacy_option: false
	}

	privacy = user.default_scope

	assert %{
	pleroma: %{notification_settings: ^notification_settings, allow_following_move: true},
	source: %{privacy: ^privacy}
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	actor_type: "Service",
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{
	actor_type: "Service",
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	ap_id: user.ap_id,
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user})
	end

	test "Represent a Funkwhale channel" do
	{:ok, user} =
	User.get_or_fetch_by_ap_id(
	"https://channels.tests.funkwhale.audio/federation/actors/compositions"
	)

	assert represented = AccountView.render("show.json", %{user: user})
	assert represented.acct == "compositions@channels.tests.funkwhale.audio"
	assert represented.url == "https://channels.tests.funkwhale.audio/channels/compositions"
	end

	test "Represent a deactivated user for an admin" do
	admin = insert(:user, is_admin: true)
	deactivated_user = insert(:user, deactivated: true)
	represented = AccountView.render("show.json", %{user: deactivated_user, for: admin})
	assert represented[:pleroma][:deactivated] == true
	end

	test "Represent a smaller mention" do
	user = insert(:user)

	expected = %{
	id: to_string(user.id),
	acct: user.nickname,
	username: user.nickname,
	url: user.ap_id
	}

	assert expected == AccountView.render("mention.json", %{user: user})
	end

	describe "relationship" do
	defp test_relationship_rendering(user, other_user, expected_result) do
	opts = %{user: user, target: other_user, relationships: nil}
	assert expected_result == AccountView.render("relationship.json", opts)

	relationships_opt = UserRelationship.view_relationships_option(user, [other_user])
	opts = Map.put(opts, :relationships, relationships_opt)
	assert expected_result == AccountView.render("relationship.json", opts)

	assert [expected_result] ==
	AccountView.render("relationships.json", %{user: user, targets: [other_user]})
	end

	@blank_response %{
	following: false,
	followed_by: false,
	blocking: false,
	blocked_by: false,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	test "represent a relationship for the following and followed user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationships} = User.mute(user, other_user, true)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, other_user)

	expected =
	Map.merge(
	@blank_response,
	%{
	following: true,
	followed_by: true,
	muting: true,
	muting_notifications: true,
	subscribing: true,
	showing_reblogs: false,
	id: to_string(other_user.id)
	}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the blocking and blocked user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationship} = User.block(user, other_user)
	{:ok, _user_relationship} = User.block(other_user, user)

	expected =
	Map.merge(
	@blank_response,
	%{following: false, blocking: true, blocked_by: true, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the user blocking a domain" do
	user = insert(:user)
	other_user = insert(:user, ap_id: "https://bad.site/users/other_user")

	{:ok, user} = User.block_domain(user, "bad.site")

	expected =
	Map.merge(
	@blank_response,
	%{domain_blocking: true, blocking: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end

	test "represent a relationship for the user with a pending follow request" do
	user = insert(:user)
	other_user = insert(:user, locked: true)

	{:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	expected =
	Map.merge(
	@blank_response,
	%{requested: true, following: false, id: to_string(other_user.id)}
	)

	test_relationship_rendering(user, other_user, expected)
	end
	end

	test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
	user = insert(:user, pleroma_settings_store: %{fe: "test"})

	result =
	AccountView.render("show.json", %{user: user, for: user, with_pleroma_settings: true})

	assert result.pleroma.settings_store == %{:fe => "test"}

	result = AccountView.render("show.json", %{user: user, with_pleroma_settings: true})
	assert result.pleroma[:settings_store] == nil

	result = AccountView.render("show.json", %{user: user, for: user})
	assert result.pleroma[:settings_store] == nil
	end

	test "doesn't sanitize display names" do
	user = insert(:user, name: "<marquee> username </marquee>")
	result = AccountView.render("show.json", %{user: user})
	assert result.display_name == "<marquee> username </marquee>"
	end

	test "never display nil user follow counts" do
	user = insert(:user, following_count: 0, follower_count: 0)
	result = AccountView.render("show.json", %{user: user})

	assert result.following_count == 0
	assert result.followers_count == 0
	end

	describe "hiding follows/following" do
	test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do
	user =
	insert(:user, %{
	hide_followers: true,
	hide_followers_count: true,
	hide_follows: true,
	hide_follows_count: true
	})

	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 0,
	following_count: 0,
	pleroma: %{hide_follows_count: true, hide_followers_count: true}
	} = AccountView.render("show.json", %{user: user})
	end

	test "shows when follows/followers are hidden" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1,
	pleroma: %{hide_follows: true, hide_followers: true}
	} = AccountView.render("show.json", %{user: user})
	end

	test "shows actual follower/following count to the account owner" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows unread_conversation_count only to the account owner" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(other_user, %{
	status: "Hey @#{user.nickname}.",
	visibility: "direct"
	})

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render("show.json", %{user: user, for: other_user})[:pleroma][
	:unread_conversation_count
	] == nil

	assert AccountView.render("show.json", %{user: user, for: user})[:pleroma][
	:unread_conversation_count
	] == 1
	end

	test "shows unread_count only to the account owner" do
	user = insert(:user)
	insert_list(7, :notification, user: user)
	other_user = insert(:user)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render(
	"show.json",
	%{user: user, for: other_user}
	)[:pleroma][:unread_notifications_count] == nil

	assert AccountView.render(
	"show.json",
	%{user: user, for: user}
	)[:pleroma][:unread_notifications_count] == 7
	end
	end

	describe "follow requests counter" do
	test "shows zero when no follow requests are pending" do
	user = insert(:user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when follow requests are pending" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when accepting a follow request" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.accept_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when rejecting a follow request" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.reject_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when historical unapproved requests are present" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	{:ok, user} = User.update_and_set_cache(user, %{locked: false})

	assert %{locked: false, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end
	end

	test "uses mediaproxy urls when it's enabled" do
	clear_config([:media_proxy, :enabled], true)

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://evil.website/avatar.png"}]},
	banner: %{"url" => [%{"href" => "https://evil.website/banner.png"}]},
	emoji: %{"joker_smile" => "https://evil.website/society.png"}
	)

	AccountView.render("show.json", %{user: user})
	\|> Enum.all?(fn
	{key, url} when key in [:avatar, :avatar_static, :header, :header_static] ->
	String.starts_with?(url, Pleroma.Web.base_url())

	{:emojis, emojis} ->
	Enum.all?(emojis, fn %{url: url, static_url: static_url} ->
	String.starts_with?(url, Pleroma.Web.base_url()) &&
	String.starts_with?(static_url, Pleroma.Web.base_url())
	end)

	_ ->
	true
	end)
	\|> assert()
	end
	end
	diff --git a/test/web/mastodon_api/views/conversation_view_test.exs b/test/web/mastodon_api/views/conversation_view_test.exs
	index 6f84366f8..2e8203c9b 100644
	--- a/test/web/mastodon_api/views/conversation_view_test.exs
	+++ b/test/web/mastodon_api/views/conversation_view_test.exs
	@@ -1,35 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.ConversationViewTest do
	use Pleroma.DataCase

	alias Pleroma.Conversation.Participation
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.ConversationView

	import Pleroma.Factory

	test "represents a Mastodon Conversation entity" do
	user = insert(:user)
	other_user = insert(:user)

	+ {:ok, parent} = CommonAPI.post(user, %{status: "parent"})
	+
	{:ok, activity} =
	- CommonAPI.post(user, %{status: "hey @#{other_user.nickname}", visibility: "direct"})
	+ CommonAPI.post(user, %{
	+ status: "hey @#{other_user.nickname}",
	+ visibility: "direct",
	+ in_reply_to_id: parent.id
	+ })
	+
	+ {:ok, _reply_activity} =
	+ CommonAPI.post(user, %{status: "hu", visibility: "public", in_reply_to_id: parent.id})

	[participation] = Participation.for_user_with_last_activity_id(user)

	assert participation

	conversation =
	ConversationView.render("participation.json", %{participation: participation, for: user})

	assert conversation.id == participation.id \|> to_string()
	assert conversation.last_status.id == activity.id

	assert [account] = conversation.accounts
	assert account.id == other_user.id
	assert conversation.last_status.pleroma.direct_conversation_id == participation.id
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 6:59 PM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723863
Default Alt Text: (492 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions