No OneTemporary
Actions

Authored By

Unknown

Size

683 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 47b66ae69..941514e18 100644
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -1,562 +1,574 @@
	image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.15.8-otp-26

	variables: &global_variables
	# Only used for the release
	ELIXIR_VER: 1.17.3
	POSTGRES_DB: pleroma_test
	POSTGRES_USER: postgres
	POSTGRES_PASSWORD: postgres
	DB_HOST: postgres
	DB_PORT: "5432"
	MIX_ENV: test
	GIT_STRATEGY: fetch

	workflow:
	rules:
	- if: $CI_PIPELINE_SOURCE == "merge_request_event"
	- if: $CI_COMMIT_BRANCH == "develop"
	- if: $CI_COMMIT_BRANCH == "stable"
	+ - if: $CI_PIPELINE_SOURCE == "web"
	+ - if: $CI_COMMIT_TAG
	- if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
	when: never

	+# Default artifacts configuration
	+.default_artifacts: &default_artifacts
	+ expire_in: 30 days
	+
	cache: &global_cache_policy
	key: $CI_JOB_IMAGE-$CI_COMMIT_SHORT_SHA
	paths:
	- deps
	- _build

	stages:
	- build
	- lint
	- test
	- check-changelog
	- benchmark
	- deploy
	- release
	- docker
	- docker-combine

	before_script:
	- echo $MIX_ENV
	- rm -rf _build/*/lib/pleroma
	- mix deps.get

	after_script:
	- rm -rf _build/*/lib/pleroma

	check-changelog:
	stage: check-changelog
	image: alpine
	rules:
	- if: $CI_MERGE_REQUEST_SOURCE_PROJECT_PATH == 'pleroma/pleroma' && $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME == 'weblate-extract'
	when: never
	- if: $CI_MERGE_REQUEST_SOURCE_PROJECT_PATH == 'pleroma/pleroma' && $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME == 'weblate'
	when: never
	- if: $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "develop"
	before_script: ''
	after_script: ''
	cache: {}
	+ artifacts: *default_artifacts
	script:
	- apk add git
	- sh ./tools/check-changelog

	.build_changes_policy:
	rules:
	- changes:
	- ".gitlab-ci.yml"
	- "*/.ex"
	- "*/.exs"
	- "mix.lock"

	.using-ci-base:
	tags:
	- amd64
	+ artifacts: *default_artifacts

	build-1.15.8-otp-26:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: build
	script:
	- mix compile --force

	build-1.18.3-otp-27:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: build
	image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.18.3-otp-27
	script:
	- mix compile --force

	spec-build:
	extends:
	- .using-ci-base
	stage: build
	rules:
	- changes:
	- ".gitlab-ci.yml"
	- "lib/pleroma/web/api_spec/*/.ex"
	- "lib/pleroma/web/api_spec.ex"
	artifacts:
	paths:
	- spec.json
	+ reports:
	+ dotenv: build.env
	+ expire_in: 42 years
	script:
	- mix pleroma.openapi_spec spec.json
	+ - echo "SPEC_BUILD_JOB_ID=$CI_JOB_ID" >> build.env

	benchmark:
	extends:
	- .using-ci-base
	stage: benchmark
	when: manual
	variables:
	MIX_ENV: benchmark
	services:
	- name: postgres:11.22-alpine
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	script:
	- mix ecto.create
	- mix ecto.migrate
	- mix pleroma.load_testing

	unit-testing-1.15.8-otp-26:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	cache: &testing_cache_policy
	<<: *global_cache_policy
	policy: pull
	services: &testing_services
	- name: postgres:13-alpine
	alias: postgres
	command: ["postgres", "-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"]
	before_script: &testing_before_script
	- echo $MIX_ENV
	- rm -rf _build/*/lib/pleroma
	# Create a non-root user for running tests
	- useradd -m -s /bin/bash testuser
	# Install dependencies as root first
	- mix deps.get
	# Set proper ownership for everything
	- chown -R testuser:testuser .
	- chown -R testuser:testuser /root/.mix \|\| true
	- chown -R testuser:testuser /root/.hex \|\| true
	# Create user-specific directories
	- su testuser -c "HOME=/home/testuser mix local.hex --force"
	- su testuser -c "HOME=/home/testuser mix local.rebar --force"
	script: &testing_script
	# Run tests as non-root user
	- su testuser -c "HOME=/home/testuser mix ecto.create"
	- su testuser -c "HOME=/home/testuser mix ecto.migrate"
	- su testuser -c "HOME=/home/testuser mix pleroma.test_runner --cover --preload-modules"
	coverage: '/^Line total: ([^ ]*%)$/'
	artifacts:
	+ expire_in: 30 days
	reports:
	coverage_report:
	coverage_format: cobertura
	path: coverage.xml

	unit-testing-1.18.3-otp-27:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: test
	image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.18.3-otp-27
	cache: *testing_cache_policy
	services: *testing_services
	before_script: *testing_before_script
	script: *testing_script

	formatting-1.15:
	extends: .build_changes_policy
	+ artifacts: *default_artifacts
	image: &formatting_elixir elixir:1.15-alpine
	stage: lint
	cache: *testing_cache_policy
	before_script: &current_bfr_script
	- apk update
	- apk add build-base cmake file-dev git openssl
	- mix local.hex --force
	- mix local.rebar --force
	- mix deps.get
	script:
	- mix format --check-formatted

	cycles-1.15:
	extends: .build_changes_policy
	+ artifacts: *default_artifacts
	image: *formatting_elixir
	stage: lint
	cache: {}
	before_script: *current_bfr_script
	script:
	- mix compile
	- mix xref graph --format cycles --label compile \| awk '{print $0} END{exit ($0 != "No cycles found")}'

	analysis:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: lint
	cache: *testing_cache_policy
	script:
	- mix credo --strict --only=warnings,todo,fixme,consistency,readability

	dialyzer:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: lint
	allow_failure: true
	- when: manual
	+ when: manual
	cache: *testing_cache_policy
	tags:
	- feld
	script:
	- mix dialyzer

	docs-deploy:
	stage: deploy
	- cache: *testing_cache_policy
	- image: alpine:latest
	+ trigger:
	+ project: pleroma/docs
	+ branch: master
	+ strategy: depend
	only:
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	- before_script:
	- - apk add curl
	- script:
	- - curl --fail-with-body -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
	+ artifacts: *default_artifacts
	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

	spec-deploy:
	stage: deploy
	- artifacts:
	- paths:
	- - spec.json
	+ trigger:
	+ project: pleroma/api-docs
	+ branch: master
	+ strategy: depend
	only:
	- develop@pleroma/pleroma
	- image: alpine:latest
	- before_script:
	- - apk add curl
	- script:
	- - curl --fail-with-body -X POST -F"token=$API_DOCS_PIPELINE_TRIGGER" -F'ref=master' -F"variables[BRANCH]=$CI_COMMIT_REF_NAME" -F"variables[JOB_REF]=$CI_JOB_ID" https://git.pleroma.social/api/v4/projects/1130/trigger/pipeline
	-
	+ variables:
	+ SPEC_BUILD_JOB_ID: $SPEC_BUILD_JOB_ID

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

	amd64:
	stage: release
	image:
	name: hexpm/elixir-amd64:1.17.3-erlang-27.3.4.2-ubuntu-noble-20250716
	only: &release-only
	- stable@pleroma/pleroma
	- develop@pleroma/pleroma
	- /^maint/.*$/@pleroma/pleroma
	- /^release/.*$/@pleroma/pleroma
	tags:
	- amd64
	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
	VIX_COMPILATION_MODE: PLATFORM_PROVIDED_LIBVIPS
	DEBIAN_FRONTEND: noninteractive
	before_script: &before-release
	- apt-get update && apt-get install -y cmake libmagic-dev libvips-dev erlang-dev git build-essential
	- echo "import Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: &release
	- mix deps.get --only prod
	- mkdir release
	- export PLEROMA_BUILD_BRANCH=$CI_COMMIT_REF_NAME
	- mix release --path release


	amd64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	image:
	name: hexpm/elixir-amd64:1.17.3-erlang-27.3.4.2-alpine-3.22.1
	tags:
	- amd64
	cache: *release-cache
	variables: *release-variables
	before_script: &before-release-musl
	- apk add git build-base cmake file-dev openssl vips-dev
	- echo "import Config" > config/prod.secret.exs
	- mix local.hex --force
	- mix local.rebar --force
	script: *release

	arm:
	stage: release
	allow_failure: true
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32-specified
	image: arm32v7/elixir:$ELIXIR_VER
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm32-specified
	image: arm32v7/elixir:$ELIXIR_VER-alpine
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	arm64:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	image:
	name: hexpm/elixir-arm64:1.17.3-erlang-27.3.4.2-ubuntu-noble-20250716
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release
	script: *release

	arm64-musl:
	stage: release
	artifacts: *release-artifacts
	only: *release-only
	tags:
	- arm
	image:
	name: hexpm/elixir-arm64:1.17.3-erlang-27.3.4.2-alpine-3.22.1
	cache: *release-cache
	variables: *release-variables
	before_script: *before-release-musl
	script: *release

	.kaniko:
	stage: docker
	image:
	name: gcr.io/kaniko-project/executor:debug
	entrypoint: [""]
	cache: {}
	dependencies: []
	before_script: &before-kaniko
	- export CI_JOB_TIMESTAMP=$(date --utc -Iseconds)
	- export CI_VCS_REF=$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG_SLUG=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:$CI_COMMIT_REF_SLUG
	- export IMAGE_TAG_LATEST=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:latest
	- export IMAGE_TAG_LATEST_STABLE=$CI_REGISTRY_IMAGE/$BUILD_ARCH_IMG_SUFFIX:latest-stable
	- mkdir -p /kaniko/.docker
	- echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json

	.kaniko-latest:
	extends: .kaniko
	only:
	- develop@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG --destination $IMAGE_TAG_LATEST

	.kaniko-stable:
	extends: .kaniko
	only:
	- stable@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG --destination $IMAGE_TAG_LATEST_STABLE

	.kaniko-release:
	extends: .kaniko
	only:
	- /^release/.*$/@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG

	.kaniko-adhoc:
	extends: .kaniko
	only:
	- /^build-docker/.*$/@pleroma/pleroma
	script:
	- /kaniko/executor --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --custom-platform=$BUILD_ARCH --build-arg VCS_REF=$CI_VCS_REF --build-arg BUILD_DATE=$CI_JOB_TIMESTAMP --build-arg ELIXIR_IMG=$ELIXIR_IMG --destination $IMAGE_TAG --destination $IMAGE_TAG_SLUG

	.kaniko:linux/amd64:
	variables:
	BUILD_ARCH: linux/amd64
	BUILD_ARCH_IMG_SUFFIX: linux-amd64
	ELIXIR_IMG: hexpm/elixir
	tags:
	- amd64

	.kaniko:linux/arm64:
	variables:
	BUILD_ARCH: linux/arm64/v8
	BUILD_ARCH_IMG_SUFFIX: linux-arm64-v8
	ELIXIR_IMG: hexpm/elixir
	tags:
	- arm

	.kaniko:linux/arm:
	variables:
	BUILD_ARCH: linux/arm/v7
	BUILD_ARCH_IMG_SUFFIX: linux-arm-v7
	ELIXIR_IMG: git.pleroma.social:5050/pleroma/ci-image/elixir-linux-arm-v7
	tags:
	- arm32-specified

	kaniko-latest:linux/amd64:
	extends:
	- .kaniko-latest
	- .kaniko:linux/amd64

	kaniko-latest:linux/arm64:
	extends:
	- .kaniko-latest
	- .kaniko:linux/arm64

	kaniko-latest:linux/arm:
	extends:
	- .kaniko-latest
	- .kaniko:linux/arm

	kaniko-stable:linux/amd64:
	extends:
	- .kaniko-stable
	- .kaniko:linux/amd64

	kaniko-stable:linux/arm64:
	extends:
	- .kaniko-stable
	- .kaniko:linux/arm64

	kaniko-stable:linux/arm:
	extends:
	- .kaniko-stable
	- .kaniko:linux/arm

	kaniko-release:linux/amd64:
	extends:
	- .kaniko-release
	- .kaniko:linux/amd64

	kaniko-release:linux/arm64:
	extends:
	- .kaniko-release
	- .kaniko:linux/arm64

	kaniko-release:linux/arm:
	extends:
	- .kaniko-release
	- .kaniko:linux/arm

	.docker-combine:
	stage: docker-combine
	image: docker:cli
	cache: {}
	before_script:
	- 'BUILD_ARCHES="linux-amd64 linux-arm64-v8 linux-arm-v7"'
	- export IMAGE_TAG=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
	- export IMAGE_TAG_SLUG=$CI_REGISTRY_IMAGE:$CI_COMMIT_REF_SLUG
	- export IMAGE_TAG_LATEST=$CI_REGISTRY_IMAGE:latest
	- export IMAGE_TAG_LATEST_STABLE=$CI_REGISTRY_IMAGE:latest-stable
	- 'IMAGES=; for arch in $BUILD_ARCHES; do IMAGES="$IMAGES $CI_REGISTRY_IMAGE/$arch:$CI_COMMIT_SHORT_SHA"; done'
	- 'IMAGES_SLUG=; for arch in $BUILD_ARCHES; do IMAGES_SLUG="$IMAGES_SLUG $CI_REGISTRY_IMAGE/$arch:$CI_COMMIT_REF_SLUG"; done'
	- 'IMAGES_LATEST=; for arch in $BUILD_ARCHES; do IMAGES_LATEST="$IMAGES_LATEST $CI_REGISTRY_IMAGE/$arch:latest"; done'
	- 'IMAGES_LATEST_STABLE=; for arch in $BUILD_ARCHES; do IMAGES_LATEST_STABLE="$IMAGES_LATEST_STABLE $CI_REGISTRY_IMAGE/$arch:latest"; done'
	- mkdir -p ~/.docker
	- echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > ~/.docker/config.json

	docker-combine:latest:
	extends: .docker-combine
	only:
	- develop@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	- 'docker manifest create $IMAGE_TAG_LATEST $IMAGES_LATEST'
	- 'docker manifest push $IMAGE_TAG_LATEST'

	docker-combine:stable:
	extends: .docker-combine
	only:
	- stable@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	- 'docker manifest create $IMAGE_TAG_LATEST_STABLE $IMAGES_LATEST_STABLE'
	- 'docker manifest push $IMAGE_TAG_LATEST_STABLE'

	docker-combine:release:
	extends: .docker-combine
	only:
	- /^release/.*$/@pleroma/pleroma
	script:
	- 'docker manifest create $IMAGE_TAG $IMAGES'
	- 'docker manifest push $IMAGE_TAG'
	- 'docker manifest create $IMAGE_TAG_SLUG $IMAGES_SLUG'
	- 'docker manifest push $IMAGE_TAG_SLUG'
	diff --git a/changelog.d/authorized_fetch.fix b/changelog.d/authorized_fetch.fix
	new file mode 100644
	index 000000000..1db8e88c9
	--- /dev/null
	+++ b/changelog.d/authorized_fetch.fix
	@@ -0,0 +1 @@
	+Fix fetching public keys with authorized fetch enabled
	\ No newline at end of file
	diff --git a/changelog.d/ci-artifacts.skip b/changelog.d/ci-artifacts.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/docs.skip b/changelog.d/docs.skip
	new file mode 100644
	index 000000000..fd1aae513
	--- /dev/null
	+++ b/changelog.d/docs.skip
	@@ -0,0 +1 @@
	+Update Differences in Mastodon API responses from vanilla Mastodon
	\ No newline at end of file
	diff --git a/changelog.d/endorsements-api.change b/changelog.d/endorsements-api.change
	new file mode 100644
	index 000000000..279392c66
	--- /dev/null
	+++ b/changelog.d/endorsements-api.change
	@@ -0,0 +1 @@
	+Support new Mastodon API for endorsed accounts
	diff --git a/changelog.d/fix-lists-bcc.fix b/changelog.d/fix-lists-bcc.fix
	new file mode 100644
	index 000000000..cd819fea3
	--- /dev/null
	+++ b/changelog.d/fix-lists-bcc.fix
	@@ -0,0 +1 @@
	+Fix publisher when publishing to a list of users
	diff --git a/changelog.d/instance-view-timeline-access.add b/changelog.d/instance-view-timeline-access.add
	new file mode 100644
	index 000000000..eb414e786
	--- /dev/null
	+++ b/changelog.d/instance-view-timeline-access.add
	@@ -0,0 +1 @@
	+Add `timelines_access` to InstanceView
	diff --git a/changelog.d/local-nickname-regex.fix b/changelog.d/local-nickname-regex.fix
	new file mode 100644
	index 000000000..81ddd9cff
	--- /dev/null
	+++ b/changelog.d/local-nickname-regex.fix
	@@ -0,0 +1 @@
	+Use end-of-string in regex for local `get_by_nickname`
	diff --git a/changelog.d/notification-cleanup.skip b/changelog.d/notification-cleanup.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/plaroma.skip b/changelog.d/plaroma.skip
	new file mode 100644
	index 000000000..184ca07e0
	--- /dev/null
	+++ b/changelog.d/plaroma.skip
	@@ -0,0 +1 @@
	+i don't think it's called plaroma
	\ No newline at end of file
	diff --git a/changelog.d/remote-url.fix b/changelog.d/remote-url.fix
	new file mode 100644
	index 000000000..9be84a878
	--- /dev/null
	+++ b/changelog.d/remote-url.fix
	@@ -0,0 +1 @@
	+`remote_url` links to unproxied URL
	diff --git a/changelog.d/rss-redirect.change b/changelog.d/rss-redirect.change
	new file mode 100644
	index 000000000..cd8b099aa
	--- /dev/null
	+++ b/changelog.d/rss-redirect.change
	@@ -0,0 +1 @@
	+Redirect /users/:nickname.rss to /users/:nickname/feed.rss instead of .atom
	\ No newline at end of file
	diff --git a/changelog.d/status-push-notification.fix b/changelog.d/status-push-notification.fix
	new file mode 100644
	index 000000000..ed0bbff33
	--- /dev/null
	+++ b/changelog.d/status-push-notification.fix
	@@ -0,0 +1 @@
	+Send push notifications for statuses from subscribed accounts
	diff --git a/changelog.d/translation-provider-mozhi.add b/changelog.d/translation-provider-mozhi.add
	new file mode 100644
	index 000000000..c3cf5940a
	--- /dev/null
	+++ b/changelog.d/translation-provider-mozhi.add
	@@ -0,0 +1 @@
	+Support Mozhi translation provider
	diff --git a/config/description.exs b/config/description.exs
	index 4c4773dbe..ddd84ceb0 100644
	--- a/config/description.exs
	+++ b/config/description.exs
	@@ -1,3603 +1,3617 @@
	import Config

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

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

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

	config :pleroma, :config_description, [
	%{
	group: :pleroma,
	key: Pleroma.Upload,
	type: :group,
	description: "Upload general settings",
	children: [
	%{
	key: :uploader,
	type: :module,
	description: "Module which will be used for uploads",
	suggestions: {:list_behaviour_implementations, Pleroma.Uploaders.Uploader}
	},
	%{
	key: :filters,
	type: {:list, :module},
	description:
	"List of filter modules for uploads. Module names are shortened (removed leading `Pleroma.Upload.Filter.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Upload.Filter}
	},
	%{
	key: :link_name,
	type: :boolean,
	description:
	"If enabled, a name parameter will be added to the URL of the upload. For example `https://instance.tld/media/imagehash.png?name=realname.png`."
	},
	%{
	key: :base_url,
	label: "Base URL",
	type: :string,
	description:
	"Base URL for the uploads. Required if you use a CDN or host attachments under a different domain.",
	suggestions: [
	"https://cdn-host.com"
	]
	},
	%{
	key: :proxy_remote,
	type: :boolean,
	description: """
	Proxy requests to the remote uploader.\n
	Useful if media upload endpoint is not internet accessible.
	"""
	},
	%{
	key: :filename_display_max_length,
	type: :integer,
	description: "Set max length of a filename to display. 0 = no limit. Default: 30"
	},
	%{
	key: :allowed_mime_types,
	label: "Allowed MIME types",
	type: {:list, :string},
	description:
	"List of MIME (main) types uploads are allowed to identify themselves with. Other types may still be uploaded, but will identify as a generic binary to clients. WARNING: Loosening this over the defaults can lead to security issues. Removing types is safe, but only add to the list if you are sure you know what you are doing.",
	suggestions: [
	"image",
	"audio",
	"video",
	"font"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Uploaders.Local,
	type: :group,
	description: "Local uploader-related settings",
	children: [
	%{
	key: :uploads,
	type: :string,
	description: "Path where user's uploads will be saved",
	suggestions: [
	"uploads"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Uploaders.IPFS,
	type: :group,
	description: "IPFS uploader-related settings",
	children: [
	%{
	key: :get_gateway_url,
	type: :string,
	description: "GET Gateway URL",
	suggestions: [
	"https://ipfs.mydomain.com/{CID}",
	"https://{CID}.ipfs.mydomain.com/"
	]
	},
	%{
	key: :post_gateway_url,
	type: :string,
	description: "POST Gateway URL",
	suggestions: [
	"http://localhost:5001/"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Uploaders.S3,
	type: :group,
	description: "S3 uploader-related settings",
	children: [
	%{
	key: :bucket,
	type: :string,
	description: "S3 bucket",
	suggestions: [
	"bucket"
	]
	},
	%{
	key: :bucket_namespace,
	type: :string,
	description: "S3 bucket namespace",
	suggestions: ["pleroma"]
	},
	%{
	key: :truncated_namespace,
	type: :string,
	description:
	"If you use S3 compatible service such as Digital Ocean Spaces or CDN, set folder name or \"\" etc." <>
	" For example, when using CDN to S3 virtual host format, set \"\". At this time, write CNAME to CDN in Upload base_url."
	},
	%{
	key: :streaming_enabled,
	type: :boolean,
	description:
	"Enable streaming uploads, when enabled the file will be sent to the server in chunks as it's being read. This may be unsupported by some providers, try disabling this if you have upload problems."
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Upload.Filter.Mogrify,
	type: :group,
	description: "Uploads mogrify filter settings",
	children: [
	%{
	key: :args,
	type: [:string, {:list, :string}, {:list, :tuple}],
	description:
	"List of actions for the mogrify command. It's possible to add self-written settings as string. " <>
	"For example `auto-orient, strip, {\"resize\", \"3840x1080>\"}` value will be parsed into valid list of the settings.",
	suggestions: [
	"strip",
	"auto-orient",
	{"implode", "1"}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Upload.Filter.AnonymizeFilename,
	type: :group,
	description: "Filter replaces the filename of the upload",
	children: [
	%{
	key: :text,
	type: :string,
	description:
	"Text to replace filenames in links. If no setting, {random}.extension will be used. You can get the original" <>
	" filename extension by using {extension}, for example custom-file-name.{extension}.",
	suggestions: [
	"custom-file-name.{extension}"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.Mailer,
	type: :group,
	description: "Mailer-related settings",
	children: [
	%{
	key: :enabled,
	label: "Mailer Enabled",
	type: :boolean
	},
	%{
	key: :adapter,
	type: :module,
	description:
	"One of the mail adapters listed in [Swoosh documentation](https://hexdocs.pm/swoosh/Swoosh.html#module-adapters)",
	suggestions: [
	Swoosh.Adapters.AmazonSES,
	Swoosh.Adapters.Dyn,
	Swoosh.Adapters.Gmail,
	Swoosh.Adapters.Mailgun,
	Swoosh.Adapters.Mailjet,
	Swoosh.Adapters.Mandrill,
	Swoosh.Adapters.Postmark,
	Swoosh.Adapters.SMTP,
	Swoosh.Adapters.Sendgrid,
	Swoosh.Adapters.Sendmail,
	Swoosh.Adapters.SocketLabs,
	Swoosh.Adapters.SparkPost
	]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :relay,
	type: :string,
	description: "Hostname or IP address",
	suggestions: ["smtp.example.com"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :port,
	type: :integer,
	description: "SMTP port",
	suggestions: ["1025"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :username,
	type: :string,
	description: "SMTP AUTH username",
	suggestions: ["user@example.com"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :password,
	type: :string,
	description: "SMTP AUTH password",
	suggestions: ["password"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :ssl,
	label: "Use SSL",
	type: :boolean,
	description: "Use Implicit SSL/TLS. e.g. port 465"
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :tls,
	label: "STARTTLS Mode",
	type: {:dropdown, :atom},
	description: "Explicit TLS (STARTTLS) enforcement mode",
	suggestions: [:if_available, :always, :never]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :auth,
	label: "AUTH Mode",
	type: {:dropdown, :atom},
	description: "SMTP AUTH enforcement mode",
	suggestions: [:if_available, :always, :never]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SMTP},
	key: :retries,
	type: :integer,
	description: "SMTP temporary (4xx) error retries",
	suggestions: [1]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendgrid},
	key: :api_key,
	label: "SendGrid API Key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :cmd_path,
	type: :string,
	suggestions: ["/usr/bin/sendmail"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :cmd_args,
	type: :string,
	suggestions: ["-N delay,failure,success"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Sendmail},
	key: :qmail,
	label: "Qmail compat mode",
	type: :boolean
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mandrill},
	key: :api_key,
	label: "Mandrill API Key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailgun},
	key: :api_key,
	label: "Mailgun API Key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailgun},
	key: :domain,
	type: :string,
	suggestions: ["YOUR_DOMAIN_NAME"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailjet},
	key: :api_key,
	label: "MailJet Public API Key",
	type: :string,
	suggestions: ["MJ_APIKEY_PUBLIC"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Mailjet},
	key: :secret,
	label: "MailJet Private API Key",
	type: :string,
	suggestions: ["MJ_APIKEY_PRIVATE"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Postmark},
	key: :api_key,
	label: "Postmark API Key",
	type: :string,
	suggestions: ["X-Postmark-Server-Token"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SparkPost},
	key: :api_key,
	label: "SparkPost API key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SparkPost},
	key: :endpoint,
	type: :string,
	suggestions: ["https://api.sparkpost.com/api/v1"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :access_key,
	label: "AWS Access Key",
	type: :string,
	suggestions: ["AWS_ACCESS_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :secret,
	label: "AWS Secret Key",
	type: :string,
	suggestions: ["AWS_SECRET_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.AmazonSES},
	key: :region,
	label: "AWS Region",
	type: :string,
	suggestions: ["us-east-1", "us-east-2"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Dyn},
	key: :api_key,
	label: "Dyn API Key",
	type: :string,
	suggestions: ["apikey"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SocketLabs},
	key: :api_key,
	label: "SocketLabs API Key",
	type: :string,
	suggestions: ["INJECTION_API_KEY"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.SocketLabs},
	key: :server_id,
	label: "Server ID",
	type: :string,
	suggestions: ["SERVER_ID"]
	},
	%{
	group: {:subgroup, Swoosh.Adapters.Gmail},
	key: :access_token,
	label: "GMail API Access Token",
	type: :string,
	suggestions: ["GMAIL_API_ACCESS_TOKEN"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :uri_schemes,
	label: "URI Schemes",
	type: :group,
	description: "URI schemes related settings",
	children: [
	%{
	key: :valid_schemes,
	type: {:list, :string},
	description: "List of the scheme part that is considered valid to be an URL",
	suggestions: [
	"https",
	"http",
	"dat",
	"dweb",
	"gopher",
	"hyper",
	"ipfs",
	"ipns",
	"irc",
	"ircs",
	"magnet",
	"mailto",
	"mumble",
	"ssb",
	"xmpp"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :features,
	type: :group,
	description: "Customizable features",
	children: [
	%{
	key: :improved_hashtag_timeline,
	type: {:dropdown, :atom},
	description:
	"Setting to force toggle / force disable improved hashtags timeline. `:enabled` forces hashtags to be fetched from `hashtags` table for hashtags timeline. `:disabled` forces object-embedded hashtags to be used (slower). Keep it `:auto` for automatic behaviour (it is auto-set to `:enabled` [unless overridden] when HashtagsTableMigrator completes).",
	suggestions: [:auto, :enabled, :disabled]
	}
	]
	},
	%{
	group: :pleroma,
	key: :populate_hashtags_table,
	type: :group,
	description: "`populate_hashtags_table` background migration settings",
	children: [
	%{
	key: :fault_rate_allowance,
	type: :float,
	description:
	"Max accepted rate of objects that failed in the migration. Any value from 0.0 which tolerates no errors to 1.0 which will enable the feature even if hashtags transfer failed for all records.",
	suggestions: [0.01]
	},
	%{
	key: :sleep_interval_ms,
	type: :integer,
	description:
	"Sleep interval between each chunk of processed records in order to decrease the load on the system (defaults to 0 and should be keep default on most instances)."
	}
	]
	},
	%{
	group: :pleroma,
	key: :delete_context_objects,
	type: :group,
	description: "`delete_context_objects` background migration settings",
	children: [
	%{
	key: :fault_rate_allowance,
	type: :float,
	description:
	"Max accepted rate of objects that failed in the migration. Any value from 0.0 which tolerates no errors to 1.0 which will enable the feature even if context object deletion failed for all records.",
	suggestions: [0.01]
	},
	%{
	key: :sleep_interval_ms,
	type: :integer,
	description:
	"Sleep interval between each chunk of processed records in order to decrease the load on the system (defaults to 0 and should be keep default on most instances)."
	}
	]
	},
	%{
	group: :pleroma,
	key: :instance,
	type: :group,
	description: "Instance-related settings",
	children: [
	%{
	key: :name,
	type: :string,
	description: "Name of the instance",
	suggestions: [
	"Pleroma"
	]
	},
	%{
	key: :email,
	label: "Admin Email Address",
	type: :string,
	description: "Email used to reach an Administrator/Moderator of the instance",
	suggestions: [
	"email@example.com"
	]
	},
	%{
	key: :notify_email,
	label: "Sender Email Address",
	type: :string,
	description: "Envelope FROM address for mail sent via Pleroma",
	suggestions: [
	"notify@example.com"
	]
	},
	%{
	key: :description,
	type: :string,
	description:
	"The instance's description. It can be seen in nodeinfo and `/api/v1/instance`",
	suggestions: [
	"Very cool instance"
	]
	},
	%{
	key: :short_description,
	type: :string,
	description:
	"Shorter version of instance description. It can be seen on `/api/v1/instance`",
	suggestions: [
	"Cool instance"
	]
	},
	%{
	key: :status_page,
	type: :string,
	description: "A page where people can see the status of the server during an outage",
	suggestions: [
	"https://status.pleroma.example.org"
	]
	},
	%{
	key: :contact_username,
	type: :string,
	description: "Instance owner username",
	suggestions: ["admin"]
	},
	%{
	key: :limit,
	type: :integer,
	description: "Posts character limit (CW/Subject included in the counter)",
	suggestions: [
	5_000
	]
	},
	%{
	key: :remote_limit,
	type: :integer,
	description: "Hard character limit beyond which remote posts will be dropped",
	suggestions: [
	100_000
	]
	},
	%{
	key: :max_media_attachments,
	type: :integer,
	description: "Maximum number of post media attachments",
	suggestions: [
	1_000_000
	]
	},
	%{
	key: :upload_limit,
	type: :integer,
	description: "File size limit of uploads (except for avatar, background, banner)",
	suggestions: [
	16_000_000
	]
	},
	%{
	key: :avatar_upload_limit,
	type: :integer,
	description: "File size limit of user's profile avatars",
	suggestions: [
	2_000_000
	]
	},
	%{
	key: :background_upload_limit,
	type: :integer,
	description: "File size limit of user's profile backgrounds",
	suggestions: [
	4_000_000
	]
	},
	%{
	key: :banner_upload_limit,
	type: :integer,
	description: "File size limit of user's profile banners",
	suggestions: [
	4_000_000
	]
	},
	%{
	key: :poll_limits,
	type: :map,
	description: "A map with poll limits for local polls",
	suggestions: [
	%{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 31_536_000
	}
	],
	children: [
	%{
	key: :max_options,
	type: :integer,
	description: "Maximum number of options",
	suggestions: [20]
	},
	%{
	key: :max_option_chars,
	type: :integer,
	description: "Maximum number of characters per option",
	suggestions: [200]
	},
	%{
	key: :min_expiration,
	type: :integer,
	description: "Minimum expiration time (in seconds)",
	suggestions: [0]
	},
	%{
	key: :max_expiration,
	type: :integer,
	description: "Maximum expiration time (in seconds)",
	suggestions: [3600]
	}
	]
	},
	%{
	key: :registrations_open,
	type: :boolean,
	description:
	"Enable registrations for anyone. Invitations require this setting to be disabled."
	},
	%{
	key: :invites_enabled,
	type: :boolean,
	description:
	"Enable user invitations for admins (depends on `registrations_open` being disabled)"
	},
	%{
	key: :account_activation_required,
	type: :boolean,
	description: "Require users to confirm their emails before signing in"
	},
	%{
	key: :account_approval_required,
	type: :boolean,
	description: "Require users to be manually approved by an admin before signing in"
	},
	%{
	key: :federating,
	type: :boolean,
	description: "Enable federation with other instances"
	},
	%{
	key: :federation_incoming_replies_max_depth,
	label: "Fed. incoming replies max depth",
	type: :integer,
	description:
	"Max. depth of reply-to and reply activities fetching on incoming federation, to prevent out-of-memory situations while" <>
	" fetching very long threads. If set to `nil`, threads of any depth will be fetched. Lower this value if you experience out-of-memory crashes.",
	suggestions: [
	100
	]
	},
	%{
	key: :federation_reachability_timeout_days,
	label: "Fed. reachability timeout days",
	type: :integer,
	description:
	"Timeout (in days) of each external federation target being unreachable prior to pausing federating to it",
	suggestions: [
	7
	]
	},
	%{
	key: :allow_relay,
	type: :boolean,
	description:
	"Permits remote instances to subscribe to all public posts of your instance. (Important!) This may increase the visibility of your instance."
	},
	%{
	key: :public,
	type: :boolean,
	description:
	"Makes the client API in authenticated mode-only except for user-profiles." <>
	" Useful for disabling the Local Timeline and The Whole Known Network. " <>
	" Note: when setting to `false`, please also check `:restrict_unauthenticated` setting."
	},
	%{
	key: :quarantined_instances,
	type: {:list, :tuple},
	key_placeholder: "instance",
	value_placeholder: "reason",
	description:
	"List of ActivityPub instances where private (DMs, followers-only) activities will not be sent and the reason for doing so",
	suggestions: [
	{"quarantined.com", "Reason"},
	{"*.quarantined.com", "Reason"}
	]
	},
	%{
	key: :rejected_instances,
	type: {:list, :tuple},
	key_placeholder: "instance",
	value_placeholder: "reason",
	description:
	"List of ActivityPub instances to reject requests from if authorized_fetch_mode is enabled",
	suggestions: [
	{"rejected.com", "Reason"},
	{"*.rejected.com", "Reason"}
	]
	},
	%{
	key: :static_dir,
	type: :string,
	description: "Instance static directory",
	suggestions: [
	"instance/static/"
	]
	},
	%{
	key: :allowed_post_formats,
	type: {:list, :string},
	description: "MIME-type list of formats allowed to be posted (transformed into HTML)",
	suggestions: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	]
	},
	%{
	key: :extended_nickname_format,
	type: :boolean,
	description:
	"Enable to use extended local nicknames format (allows underscores/dashes)." <>
	" This will break federation with older software for theses nicknames."
	},
	%{
	key: :cleanup_attachments,
	type: :boolean,
	description: """
	Enable to remove associated attachments when status is removed.
	This will not affect duplicates and attachments without status.
	Enabling this will increase load to database when deleting statuses on larger instances.
	"""
	},
	%{
	key: :max_pinned_statuses,
	type: :integer,
	description: "The maximum number of pinned statuses. 0 will disable the feature.",
	suggestions: [
	0,
	1,
	3
	]
	},
	%{
	key: :max_endorsed_users,
	type: :integer,
	description: "The maximum number of recommended accounts. 0 will disable the feature.",
	suggestions: [
	0,
	1,
	3
	]
	},
	%{
	key: :autofollowed_nicknames,
	type: {:list, :string},
	description:
	"Set to nicknames of (local) users that every new user should automatically follow"
	},
	%{
	key: :autofollowing_nicknames,
	type: {:list, :string},
	description:
	"Set to nicknames of (local) users that automatically follows every newly registered user"
	},
	%{
	key: :attachment_links,
	type: :boolean,
	description: "Enable to automatically add attachment link text to statuses"
	},
	%{
	key: :max_report_comment_size,
	type: :integer,
	description: "The maximum size of the report comment. Default: 1000.",
	suggestions: [
	1_000
	]
	},
	%{
	key: :report_strip_status,
	label: "Report strip status",
	type: :boolean,
	description:
	"Strip associated statuses in reports to ids when closed/resolved, otherwise keep a copy"
	},
	%{
	key: :safe_dm_mentions,
	label: "Safe DM mentions",
	type: :boolean,
	description:
	"If enabled, only mentions at the beginning of a post will be used to address people in direct messages." <>
	" This is to prevent accidental mentioning of people when talking about them (e.g. \"@admin please keep an eye on @bad_actor\")." <>
	" Default: disabled"
	},
	%{
	key: :healthcheck,
	type: :boolean,
	description: "If enabled, system data will be shown on `/api/pleroma/healthcheck`"
	},
	%{
	key: :remote_post_retention_days,
	type: :integer,
	description:
	"The default amount of days to retain remote posts when pruning the database",
	suggestions: [
	90
	]
	},
	%{
	key: :user_bio_length,
	type: :integer,
	description: "A user bio maximum length. Default: 5000.",
	suggestions: [
	5_000
	]
	},
	%{
	key: :user_name_length,
	type: :integer,
	description: "A user name maximum length. Default: 100.",
	suggestions: [
	100
	]
	},
	%{
	key: :skip_thread_containment,
	type: :boolean,
	description: "Skip filtering out broken threads. Default: enabled."
	},
	%{
	key: :limit_to_local_content,
	type: {:dropdown, :atom},
	description:
	"Limit unauthenticated users to search for local statutes and users only. Default: `:unauthenticated`.",
	suggestions: [
	:unauthenticated,
	:all,
	false
	]
	},
	%{
	key: :max_account_fields,
	type: :integer,
	description: "The maximum number of custom fields in the user profile. Default: 10.",
	suggestions: [
	10
	]
	},
	%{
	key: :max_remote_account_fields,
	type: :integer,
	description:
	"The maximum number of custom fields in the remote user profile. Default: 20.",
	suggestions: [
	20
	]
	},
	%{
	key: :account_field_name_length,
	type: :integer,
	description: "An account field name maximum length. Default: 512.",
	suggestions: [
	512
	]
	},
	%{
	key: :account_field_value_length,
	type: :integer,
	description: "An account field value maximum length. Default: 2048.",
	suggestions: [
	2048
	]
	},
	%{
	key: :registration_reason_length,
	type: :integer,
	description: "Maximum registration reason length. Default: 500.",
	suggestions: [
	500
	]
	},
	%{
	key: :external_user_synchronization,
	type: :boolean,
	description: "Enabling following/followers counters synchronization for external users"
	},
	%{
	key: :multi_factor_authentication,
	type: :keyword,
	description: "Multi-factor authentication settings",
	suggestions: [
	[
	totp: [digits: 6, period: 30],
	backup_codes: [number: 5, length: 16]
	]
	],
	children: [
	%{
	key: :totp,
	label: "TOTP settings",
	type: :keyword,
	description: "TOTP settings",
	suggestions: [digits: 6, period: 30],
	children: [
	%{
	key: :digits,
	type: :integer,
	suggestions: [6],
	description:
	"Determines the length of a one-time pass-code, in characters. Defaults to 6 characters."
	},
	%{
	key: :period,
	type: :integer,
	suggestions: [30],
	description:
	"A period for which the TOTP code will be valid, in seconds. Defaults to 30 seconds."
	}
	]
	},
	%{
	key: :backup_codes,
	type: :keyword,
	description: "MFA backup codes settings",
	suggestions: [number: 5, length: 16],
	children: [
	%{
	key: :number,
	type: :integer,
	suggestions: [5],
	description: "Number of backup codes to generate."
	},
	%{
	key: :length,
	type: :integer,
	suggestions: [16],
	description:
	"Determines the length of backup one-time pass-codes, in characters. Defaults to 16 characters."
	}
	]
	}
	]
	},
	%{
	key: :instance_thumbnail,
	type: {:string, :image},
	description:
	"The instance thumbnail can be any image that represents your instance and is used by some apps or services when they display information about your instance.",
	suggestions: ["/instance/thumbnail.jpeg"]
	},
	%{
	key: :favicon,
	type: {:string, :image},
	description: "Favicon of the instance",
	suggestions: ["/favicon.png"]
	},
	%{
	key: :show_reactions,
	type: :boolean,
	description: "Let favourites and emoji reactions be viewed through the API."
	},
	%{
	key: :profile_directory,
	type: :boolean,
	description: "Enable profile directory."
	},
	%{
	key: :admin_privileges,
	type: {:list, :atom},
	suggestions: [
	:users_read,
	:users_manage_invites,
	:users_manage_activation_state,
	:users_manage_tags,
	:users_manage_credentials,
	:users_delete,
	:messages_read,
	:messages_delete,
	:instances_delete,
	:reports_manage_reports,
	:moderation_log_read,
	:announcements_manage_announcements,
	:emoji_manage_emoji,
	:statistics_read
	],
	description:
	"What extra privileges to allow admins (e.g. updating user credentials, get password reset token, delete users, index and read private statuses and chats)"
	},
	%{
	key: :moderator_privileges,
	type: {:list, :atom},
	suggestions: [
	:users_read,
	:users_manage_invites,
	:users_manage_activation_state,
	:users_manage_tags,
	:users_manage_credentials,
	:users_delete,
	:messages_read,
	:messages_delete,
	:instances_delete,
	:reports_manage_reports,
	:moderation_log_read,
	:announcements_manage_announcements,
	:emoji_manage_emoji,
	:statistics_read
	],
	description:
	"What extra privileges to allow moderators (e.g. updating user credentials, get password reset token, delete users, index and read private statuses and chats)"
	},
	%{
	key: :birthday_required,
	type: :boolean,
	description: "Require users to enter their birthday."
	},
	%{
	key: :birthday_min_age,
	type: :integer,
	description:
	"Minimum required age (in days) for users to create account. Only used if birthday is required.",
	suggestions: [6570]
	},
	%{
	key: :languages,
	type: {:list, :string},
	description:
	"Languages to be exposed in /api/v1/instance. Should be in the format of BCP47 language codes.",
	suggestions: [
	"en"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :welcome,
	type: :group,
	description: "Welcome messages settings",
	children: [
	%{
	key: :direct_message,
	type: :keyword,
	descpiption: "Direct message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending a direct message to newly registered users"
	},
	%{
	key: :message,
	type: :string,
	description: "A message that will be sent to newly registered users",
	suggestions: [
	"Hi, @username! Welcome on board!"
	]
	},
	%{
	key: :sender_nickname,
	type: :string,
	description: "The nickname of the local user that sends a welcome message",
	suggestions: [
	"lain"
	]
	}
	]
	},
	%{
	key: :chat_message,
	type: :keyword,
	descpiption: "Chat message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending a chat message to newly registered users"
	},
	%{
	key: :message,
	type: :string,
	description:
	"A message that will be sent to newly registered users as a chat message",
	suggestions: [
	"Hello, welcome on board!"
	]
	},
	%{
	key: :sender_nickname,
	type: :string,
	description: "The nickname of the local user that sends a welcome chat message",
	suggestions: [
	"lain"
	]
	}
	]
	},
	%{
	key: :email,
	type: :keyword,
	descpiption: "Email message settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables sending an email to newly registered users"
	},
	%{
	key: :sender,
	type: [:string, :tuple],
	description:
	"Email address and/or nickname that will be used to send the welcome email.",
	suggestions: [
	{"Pleroma App", "welcome@pleroma.app"}
	]
	},
	%{
	key: :subject,
	type: :string,
	description:
	"Subject of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["Welcome to <%= instance_name%>"]
	},
	%{
	key: :html,
	type: :string,
	description:
	"HTML content of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["<h1>Hello <%= user.name%>. Welcome to <%= instance_name%></h1>"]
	},
	%{
	key: :text,
	type: :string,
	description:
	"Text content of the welcome email. EEX template with user and instance_name variables can be used.",
	suggestions: ["Hello <%= user.name%>. \n Welcome to <%= instance_name%>\n"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :frontend_configurations,
	type: :group,
	description:
	"This form can be used to configure a keyword list that keeps the configuration data for any " <>
	"kind of frontend. By default, settings for pleroma_fe are configured. If you want to " <>
	"add your own configuration your settings all fields must be complete.",
	children: [
	%{
	key: :pleroma_fe,
	label: "Pleroma FE",
	type: :map,
	description: "Settings for Pleroma FE",
	suggestions: [
	%{
	alwaysShowSubjectInput: true,
	background: "/static/aurora_borealis.jpg",
	collapseMessageWithSubject: false,
	greentext: false,
	embeddedToS: true,
	hideFilteredStatuses: false,
	hideMutedPosts: false,
	hidePostStats: false,
	hideSitename: false,
	hideUserStats: false,
	loginMethod: "password",
	logo: "/static/logo.svg",
	logoMargin: ".1em",
	logoMask: true,
	minimalScopesMode: false,
	noAttachmentLinks: false,
	nsfwCensorImage: "/static/img/nsfw.74818f9.png",
	postContentType: "text/plain",
	redirectRootLogin: "/main/friends",
	redirectRootNoLogin: "/main/all",
	scopeCopy: true,
	sidebarRight: false,
	showFeaturesPanel: true,
	showInstanceSpecificPanel: false,
	subjectLineBehavior: "email",
	theme: "pleroma-dark",
	webPushNotifications: false
	}
	],
	children: [
	%{
	key: :alwaysShowSubjectInput,
	label: "Always show subject input",
	type: :boolean,
	description: "When disabled, auto-hide the subject field if it's empty"
	},
	%{
	key: :background,
	type: {:string, :image},
	description:
	"URL of the background, unless viewing a user profile with a background that is set",
	suggestions: ["/images/city.jpg"]
	},
	%{
	key: :collapseMessageWithSubject,
	label: "Collapse message with subject",
	type: :boolean,
	description:
	"When a message has a subject (aka Content Warning), collapse it by default"
	},
	%{
	key: :greentext,
	label: "Greentext",
	type: :boolean,
	description: "Enables green text on lines prefixed with the > character"
	},
	%{
	key: :embeddedToS,
	label: "Embedded ToS panel",
	type: :boolean,
	description: "Hide Terms of Service panel decorations on About and Registration pages"
	},
	%{
	key: :hideFilteredStatuses,
	label: "Hide Filtered Statuses",
	type: :boolean,
	description: "Hides filtered statuses from timelines"
	},
	%{
	key: :hideMutedPosts,
	label: "Hide Muted Posts",
	type: :boolean,
	description: "Hides muted statuses from timelines"
	},
	%{
	key: :hidePostStats,
	label: "Hide post stats",
	type: :boolean,
	description: "Hide notices statistics (repeats, favorites, ...)"
	},
	%{
	key: :hideSitename,
	label: "Hide Sitename",
	type: :boolean,
	description: "Hides instance name from PleromaFE banner"
	},
	%{
	key: :hideUserStats,
	label: "Hide user stats",
	type: :boolean,
	description:
	"Hide profile statistics (posts, posts per day, followers, followings, ...)"
	},
	%{
	key: :logo,
	type: {:string, :image},
	description: "URL of the logo, defaults to Pleroma's logo",
	suggestions: ["/static/logo.svg"]
	},
	%{
	key: :logoMargin,
	label: "Logo margin",
	type: :string,
	description:
	"Allows you to adjust vertical margins between logo boundary and navbar borders. " <>
	"The idea is that to have logo's image without any extra margins and instead adjust them to your need in layout.",
	suggestions: [".1em"]
	},
	%{
	key: :logoMask,
	label: "Logo mask",
	type: :boolean,
	description:
	"By default it assumes logo used will be monochrome with alpha channel to be compatible with both light and dark themes. " <>
	"If you want a colorful logo you must disable logoMask."
	},
	%{
	key: :minimalScopesMode,
	label: "Minimal scopes mode",
	type: :boolean,
	description:
	"Limit scope selection to Direct, User default, and Scope of post replying to. " <>
	"Also prevents replying to a DM with a public post from PleromaFE."
	},
	%{
	key: :nsfwCensorImage,
	label: "NSFW Censor Image",
	type: {:string, :image},
	description:
	"URL of the image to use for hiding NSFW media attachments in the timeline",
	suggestions: ["/static/img/nsfw.74818f9.png"]
	},
	%{
	key: :postContentType,
	label: "Post Content Type",
	type: {:dropdown, :atom},
	description: "Default post formatting option",
	suggestions: ["text/plain", "text/html", "text/markdown", "text/bbcode"]
	},
	%{
	key: :redirectRootNoLogin,
	label: "Redirect root no login",
	type: :string,
	description:
	"Relative URL which indicates where to redirect when a user isn't logged in",
	suggestions: ["/main/all"]
	},
	%{
	key: :redirectRootLogin,
	label: "Redirect root login",
	type: :string,
	description:
	"Relative URL which indicates where to redirect when a user is logged in",
	suggestions: ["/main/friends"]
	},
	%{
	key: :scopeCopy,
	label: "Scope copy",
	type: :boolean,
	description: "Copy the scope (private/unlisted/public) in replies to posts by default"
	},
	%{
	key: :sidebarRight,
	label: "Sidebar on Right",
	type: :boolean,
	description: "Change alignment of sidebar and panels to the right"
	},
	%{
	key: :showFeaturesPanel,
	label: "Show instance features panel",
	type: :boolean,
	description:
	"Enables panel displaying functionality of the instance on the About page"
	},
	%{
	key: :showInstanceSpecificPanel,
	label: "Show instance specific panel",
	type: :boolean,
	description: "Whether to show the instance's custom panel"
	},
	%{
	key: :subjectLineBehavior,
	label: "Subject line behavior",
	type: :string,
	description: "Allows changing the default behaviour of subject lines in replies.
	`email`: copy and prepend re:, as in email,
	`masto`: copy verbatim, as in Mastodon,
	`noop`: don't copy the subject.",
	suggestions: ["email", "masto", "noop"]
	},
	%{
	key: :theme,
	type: :string,
	description: "Which theme to use. Available themes are defined in styles.json",
	suggestions: ["pleroma-dark"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :assets,
	type: :group,
	description:
	"This section configures assets to be used with various frontends. Currently the only option relates to mascots on the mastodon frontend",
	children: [
	%{
	key: :mascots,
	type: {:keyword, :map},
	description:
	"Keyword of mascots, each element must contain both an URL and a mime_type key",
	suggestions: [
	pleroma_fox_tan: %{
	url: "/images/pleroma-fox-tan-smol.png",
	mime_type: "image/png"
	},
	pleroma_fox_tan_shy: %{
	url: "/images/pleroma-fox-tan-shy.png",
	mime_type: "image/png"
	}
	]
	},
	%{
	key: :default_mascot,
	type: :atom,
	description:
	"This will be used as the default mascot on MastoFE. Default: `:pleroma_fox_tan`",
	suggestions: [
	:pleroma_fox_tan
	]
	},
	%{
	key: :default_user_avatar,
	type: {:string, :image},
	description: "URL of the default user avatar",
	suggestions: ["/images/avi.png"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :manifest,
	type: :group,
	description:
	"This section describe PWA manifest instance-specific values. Currently this option relate only for MastoFE.",
	children: [
	%{
	key: :icons,
	type: {:list, :map},
	description: "Describe the icons of the app",
	suggestion: [
	%{
	src: "/static/logo.png"
	},
	%{
	src: "/static/icon.png",
	type: "image/png"
	},
	%{
	src: "/static/icon.ico",
	sizes: "72x72 96x96 128x128 256x256"
	}
	]
	},
	%{
	key: :theme_color,
	type: :string,
	description: "Describe the theme color of the app",
	suggestions: ["#282c37", "mediumpurple"]
	},
	%{
	key: :background_color,
	type: :string,
	description: "Describe the background color of the app",
	suggestions: ["#191b22", "aliceblue"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :media_proxy,
	type: :group,
	description: "Media proxy",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables proxying of remote media via the instance's proxy"
	},
	%{
	key: :base_url,
	label: "Base URL",
	type: :string,
	description:
	"The base URL to access a user-uploaded file. Useful when you want to proxy the media files via another host/CDN fronts.",
	suggestions: ["https://example.com"]
	},
	%{
	key: :invalidation,
	type: :keyword,
	descpiption: "",
	suggestions: [
	enabled: true,
	provider: Pleroma.Web.MediaProxy.Invalidation.Script
	],
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables media cache object invalidation."
	},
	%{
	key: :provider,
	type: :module,
	description: "Module which will be used to purge objects from the cache.",
	suggestions: [
	Pleroma.Web.MediaProxy.Invalidation.Script,
	Pleroma.Web.MediaProxy.Invalidation.Http
	]
	}
	]
	},
	%{
	key: :proxy_opts,
	label: "Advanced MediaProxy Options",
	type: :keyword,
	description: "Internal Pleroma.ReverseProxy settings",
	suggestions: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	max_read_duration: 30_000
	],
	children: [
	%{
	key: :redirect_on_failure,
	type: :boolean,
	description: """
	Redirects the client to the origin server upon encountering HTTP errors.\n
	Note that files larger than Max Body Length will trigger an error. (e.g., Peertube videos)\n\n
	WARNING: This setting will allow larger files to be accessed, but exposes the\n
	IP addresses of your users to the other servers, bypassing the MediaProxy.
	"""
	},
	%{
	key: :max_body_length,
	type: :integer,
	description:
	"Maximum file size (in bytes) allowed through the Pleroma MediaProxy cache."
	},
	%{
	key: :max_read_duration,
	type: :integer,
	description: "Timeout (in milliseconds) of GET request to the remote URI."
	}
	]
	},
	%{
	key: :whitelist,
	type: {:list, :string},
	description: "List of hosts with scheme to bypass the MediaProxy",
	suggestions: ["http://example.com"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :media_preview_proxy,
	type: :group,
	description: "Media preview proxy",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description:
	"Enables proxying of remote media preview to the instance's proxy. Requires enabled media proxy."
	},
	%{
	key: :thumbnail_max_width,
	type: :integer,
	description:
	"Max width of preview thumbnail for images (video preview always has original dimensions)."
	},
	%{
	key: :thumbnail_max_height,
	type: :integer,
	description:
	"Max height of preview thumbnail for images (video preview always has original dimensions)."
	},
	%{
	key: :image_quality,
	type: :integer,
	description: "Quality of the output. Ranges from 0 (min quality) to 100 (max quality)."
	},
	%{
	key: :min_content_length,
	type: :integer,
	description:
	"Min content length (in bytes) to perform preview. Media smaller in size will be served without thumbnailing."
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.MediaProxy.Invalidation.Http,
	type: :group,
	description: "HTTP invalidate settings",
	children: [
	%{
	key: :method,
	type: :atom,
	description: "HTTP method of request. Default: :purge"
	},
	%{
	key: :headers,
	type: {:keyword, :string},
	description: "HTTP headers of request",
	suggestions: [{"x-refresh", 1}]
	},
	%{
	key: :options,
	type: :keyword,
	description: "Request options",
	children: [
	%{
	key: :params,
	type: {:map, :string}
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.MediaProxy.Invalidation.Script,
	type: :group,
	description: "Invalidation script settings",
	children: [
	%{
	key: :script_path,
	type: :string,
	description: "Path to executable script which will purge cached items.",
	suggestions: ["./installation/nginx-cache-purge.sh.example"]
	},
	%{
	key: :url_format,
	label: "URL Format",
	type: :string,
	description:
	"Optional URL format preprocessing. Only required for Apache's htcacheclean.",
	suggestions: [":htcacheclean"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :gopher,
	type: :group,
	description: "Gopher settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables the gopher interface"
	},
	%{
	key: :ip,
	label: "IP",
	type: :tuple,
	description: "IP address to bind to",
	suggestions: [{0, 0, 0, 0}]
	},
	%{
	key: :port,
	type: :integer,
	description: "Port to bind to",
	suggestions: [9999]
	},
	%{
	key: :dstport,
	type: :integer,
	description: "Port advertised in URLs (optional, defaults to port)",
	suggestions: [9999]
	}
	]
	},
	%{
	group: :pleroma,
	key: :activitypub,
	label: "ActivityPub",
	type: :group,
	description: "ActivityPub-related settings",
	children: [
	%{
	key: :unfollow_blocked,
	type: :boolean,
	description: "Whether blocks result in people getting unfollowed"
	},
	%{
	key: :outgoing_blocks,
	type: :boolean,
	description: "Whether to federate blocks to other instances"
	},
	%{
	key: :blockers_visible,
	type: :boolean,
	description: "Whether a user can see someone who has blocked them"
	},
	%{
	key: :sign_object_fetches,
	type: :boolean,
	description: "Sign object fetches with HTTP signatures"
	},
	%{
	key: :authorized_fetch_mode,
	type: :boolean,
	description: "Require HTTP signatures for AP fetches"
	},
	%{
	key: :authorized_fetch_mode_exceptions,
	type: {:list, :string},
	description:
	"List of IPs (CIDR format accepted) to exempt from HTTP Signatures requirement (for example to allow debugging, you shouldn't otherwise need this)"
	},
	%{
	key: :note_replies_output_limit,
	type: :integer,
	description:
	"The number of Note replies' URIs to be included with outgoing federation (`5` to match Mastodon hardcoded value, `0` to disable the output)"
	},
	%{
	key: :follow_handshake_timeout,
	type: :integer,
	description: "Following handshake timeout",
	suggestions: [500]
	},
	%{
	key: :client_api_enabled,
	type: :boolean,
	description: "Allow client to server ActivityPub interactions"
	},
	%{
	key: :anonymize_reporter,
	type: :boolean,
	label: "Anonymize local reports",
	description:
	"If true, replace local reporters with the designated local user for the copy to be sent to remote servers"
	},
	%{
	key: :anonymize_reporter_local_nickname,
	type: :string,
	label: "Anonymized reporter",
	description:
	"The nickname of the designated local user that replaces the actual reporter in the copy to be sent to remote servers",
	suggestions: [
	"lain"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :http_security,
	label: "HTTP security",
	type: :group,
	description: "HTTP security settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether the managed content security policy is enabled"
	},
	%{
	key: :sts,
	label: "STS",
	type: :boolean,
	description: "Whether to additionally send a Strict-Transport-Security header"
	},
	%{
	key: :sts_max_age,
	label: "STS max age",
	type: :integer,
	description: "The maximum age for the Strict-Transport-Security header if sent",
	suggestions: [31_536_000]
	},
	%{
	key: :ct_max_age,
	label: "CT max age",
	type: :integer,
	description: "The maximum age for the Expect-CT header if sent",
	suggestions: [2_592_000]
	},
	%{
	key: :referrer_policy,
	type: :string,
	description: "The referrer policy to use, either \"same-origin\" or \"no-referrer\"",
	suggestions: ["same-origin", "no-referrer"]
	},
	%{
	key: :report_uri,
	label: "Report URI",
	type: :string,
	description: "Adds the specified URL to report-uri and report-to group in CSP header",
	suggestions: ["https://example.com/report-uri"]
	}
	]
	},
	%{
	group: :web_push_encryption,
	key: :vapid_details,
	label: "Vapid Details",
	type: :group,
	description:
	"Web Push Notifications configuration. You can use the mix task mix web_push.gen.keypair to generate it.",
	children: [
	%{
	key: :subject,
	type: :string,
	description:
	"A mailto link for the administrative contact." <>
	" It's best if this email is not a personal email address, but rather a group email to the instance moderation team.",
	suggestions: ["mailto:moderators@pleroma.com"]
	},
	%{
	key: :public_key,
	type: :string,
	description: "VAPID public key",
	suggestions: ["Public key"]
	},
	%{
	key: :private_key,
	type: :string,
	description: "VAPID private key",
	suggestions: ["Private key"]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Captcha,
	type: :group,
	description: "Captcha-related settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether the captcha should be shown on registration"
	},
	%{
	key: :method,
	type: :module,
	description: "The method/service to use for captcha",
	suggestions: [Pleroma.Captcha.Kocaptcha, Pleroma.Captcha.Native]
	},
	%{
	key: :seconds_valid,
	type: :integer,
	description: "The time in seconds for which the captcha is valid",
	suggestions: [60]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Captcha.Kocaptcha,
	type: :group,
	description:
	"Kocaptcha is a very simple captcha service with a single API endpoint, the source code is" <>
	" here: https://github.com/koto-bank/kocaptcha. The default endpoint (https://captcha.kotobank.ch) is hosted by the developer.",
	children: [
	%{
	key: :endpoint,
	type: :string,
	description: "The kocaptcha endpoint to use",
	suggestions: ["https://captcha.kotobank.ch"]
	}
	]
	},
	%{
	group: :pleroma,
	label: "Pleroma Admin Token",
	type: :group,
	description:
	"Allows setting a token that can be used to authenticate requests with admin privileges without a normal user account token. Append the `admin_token` parameter to requests to utilize it. (Please reconsider using HTTP Basic Auth or OAuth-based authentication if possible)",
	children: [
	%{
	key: :admin_token,
	type: :string,
	description: "Admin token",
	suggestions: [
	"Please use a high entropy string or UUID"
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Oban,
	type: :group,
	description:
	"[Oban](https://github.com/sorentwo/oban) asynchronous job processor configuration.",
	children: [
	%{
	key: :log,
	type: {:dropdown, :atom},
	description: "Logs verbose mode",
	suggestions: [false, :error, :warning, :info, :debug]
	},
	%{
	key: :queues,
	type: {:keyword, :integer},
	description:
	"Background jobs queues (keys: queues, values: max numbers of concurrent jobs)",
	suggestions: [
	activity_expiration: 10,
	attachments_cleanup: 5,
	background: 5,
	federator_incoming: 50,
	federator_outgoing: 50,
	mailer: 10,
	scheduled_activities: 10,
	transmogrifier: 20,
	web_push: 50
	],
	children: [
	%{
	key: :activity_expiration,
	type: :integer,
	description: "Activity expiration queue",
	suggestions: [10]
	},
	%{
	key: :backup,
	type: :integer,
	description: "Backup queue",
	suggestions: [1]
	},
	%{
	key: :attachments_cleanup,
	type: :integer,
	description: "Attachment deletion queue",
	suggestions: [5]
	},
	%{
	key: :background,
	type: :integer,
	description: "Background queue",
	suggestions: [5]
	},
	%{
	key: :federator_incoming,
	type: :integer,
	description: "Incoming federation queue",
	suggestions: [50]
	},
	%{
	key: :federator_outgoing,
	type: :integer,
	description: "Outgoing federation queue",
	suggestions: [50]
	},
	%{
	key: :mailer,
	type: :integer,
	description: "Email sender queue, see Pleroma.Emails.Mailer",
	suggestions: [10]
	},
	%{
	key: :scheduled_activities,
	type: :integer,
	description: "Scheduled activities queue, see Pleroma.ScheduledActivities",
	suggestions: [10]
	},
	%{
	key: :transmogrifier,
	type: :integer,
	description: "Transmogrifier queue",
	suggestions: [20]
	},
	%{
	key: :web_push,
	type: :integer,
	description: "Web push notifications queue",
	suggestions: [50]
	}
	]
	},
	%{
	key: :crontab,
	type: {:list, :tuple},
	description: "Settings for cron background jobs",
	suggestions: [
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.Metadata,
	type: :group,
	description: "Metadata-related settings",
	children: [
	%{
	key: :providers,
	type: {:list, :module},
	description: "List of metadata providers to enable",
	suggestions: [
	Pleroma.Web.Metadata.Providers.OpenGraph,
	Pleroma.Web.Metadata.Providers.TwitterCard,
	Pleroma.Web.Metadata.Providers.RelMe,
	Pleroma.Web.Metadata.Providers.Feed
	]
	},
	%{
	key: :unfurl_nsfw,
	label: "Unfurl NSFW",
	type: :boolean,
	description: "When enabled NSFW attachments will be shown in previews"
	}
	]
	},
	%{
	group: :pleroma,
	key: :rich_media,
	type: :group,
	description:
	"If enabled the instance will parse metadata from attached links to generate link previews",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables RichMedia parsing of URLs"
	},
	%{
	key: :ignore_hosts,
	type: {:list, :string},
	description: "List of hosts which will be ignored by the metadata parser",
	suggestions: ["accounts.google.com", "xss.website"]
	},
	%{
	key: :ignore_tld,
	label: "Ignore TLD",
	type: {:list, :string},
	description: "List TLDs (top-level domains) which will ignore for parse metadata",
	suggestions: ["local", "localdomain", "lan"]
	},
	%{
	key: :parsers,
	type: {:list, :module},
	description:
	"List of Rich Media parsers. Module names are shortened (removed leading `Pleroma.Web.RichMedia.Parsers.` part), but on adding custom module you need to use full name.",
	suggestions: [
	Pleroma.Web.RichMedia.Parsers.OEmbed,
	Pleroma.Web.RichMedia.Parsers.TwitterCard
	]
	},
	%{
	key: :ttl_setters,
	label: "TTL setters",
	type: {:list, :module},
	description:
	"List of rich media TTL setters. Module names are shortened (removed leading `Pleroma.Web.RichMedia.Parser.` part), but on adding custom module you need to use full name.",
	suggestions: [
	Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl
	]
	},
	%{
	key: :timeout,
	type: :integer,
	description:
	"Amount of milliseconds after which the HTTP request is forcibly terminated.",
	suggestions: [5_000]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Formatter,
	label: "Linkify",
	type: :group,
	description:
	"Configuration for Pleroma's link formatter which parses mentions, hashtags, and URLs.",
	children: [
	%{
	key: :class,
	type: [:string, :boolean],
	description: "Specify the class to be added to the generated link. Disable to clear.",
	suggestions: ["auto-linker", false]
	},
	%{
	key: :rel,
	type: [:string, :boolean],
	description: "Override the rel attribute. Disable to clear.",
	suggestions: ["ugc", "noopener noreferrer", false]
	},
	%{
	key: :new_window,
	type: :boolean,
	description: "Link URLs will open in a new window/tab."
	},
	%{
	key: :truncate,
	type: [:integer, :boolean],
	description:
	"Set to a number to truncate URLs longer than the number. Truncated URLs will end in `...`",
	suggestions: [15, false]
	},
	%{
	key: :strip_prefix,
	type: :boolean,
	description: "Strip the scheme prefix."
	},
	%{
	key: :extra,
	type: :boolean,
	description: "Link URLs with rarely used schemes (magnet, ipfs, irc, etc.)"
	},
	%{
	key: :validate_tld,
	type: [:atom, :boolean],
	description:
	"Set to false to disable TLD validation for URLs/emails. Can be set to :no_scheme to validate TLDs only for URLs without a scheme (e.g `example.com` will be validated, but `http://example.loki` won't)",
	suggestions: [:no_scheme, true]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.ScheduledActivity,
	type: :group,
	description: "Scheduled activities settings",
	children: [
	%{
	key: :daily_user_limit,
	type: :integer,
	description:
	"The number of scheduled activities a user is allowed to create in a single day. Default: 25.",
	suggestions: [25]
	},
	%{
	key: :total_user_limit,
	type: :integer,
	description:
	"The number of scheduled activities a user is allowed to create in total. Default: 300.",
	suggestions: [300]
	},
	%{
	key: :enabled,
	type: :boolean,
	description: "Whether scheduled activities are sent to the job queue to be executed"
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Workers.PurgeExpiredActivity,
	type: :group,
	description: "Expired activities settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables expired activities addition & deletion"
	},
	%{
	key: :min_lifetime,
	type: :integer,
	description: "Minimum lifetime for ephemeral activity (in seconds)",
	suggestions: [600]
	}
	]
	},
	%{
	group: :pleroma,
	label: "Pleroma Authenticator",
	type: :group,
	description: "Authenticator",
	children: [
	%{
	key: Pleroma.Web.Auth.Authenticator,
	type: :module,
	suggestions: [Pleroma.Web.Auth.PleromaAuthenticator, Pleroma.Web.Auth.LDAPAuthenticator]
	}
	]
	},
	%{
	group: :pleroma,
	key: :ldap,
	label: "LDAP",
	type: :group,
	description:
	"Use LDAP for user authentication. When a user logs in to the Pleroma instance, the name and password" <>
	" will be verified by trying to authenticate (bind) to a LDAP server." <>
	" If a user exists in the LDAP directory but there is no account with the same name yet on the" <>
	" Pleroma instance then a new Pleroma account will be created with the same name as the LDAP user name.",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables LDAP authentication"
	},
	%{
	key: :host,
	type: :string,
	description: "LDAP server hostname",
	suggestions: ["localhosts"]
	},
	%{
	key: :port,
	type: :integer,
	description: "LDAP port, e.g. 389 or 636",
	suggestions: [389, 636]
	},
	%{
	key: :ssl,
	label: "SSL",
	type: :boolean,
	description: "Enable to use SSL, usually implies the port 636"
	},
	%{
	key: :sslopts,
	label: "SSL options",
	type: :keyword,
	description: "Additional SSL options",
	suggestions: [verify: :verify_peer],
	children: [
	%{
	key: :verify,
	type: :atom,
	description: "Type of cert verification",
	suggestions: [:verify_peer]
	}
	]
	},
	%{
	key: :tls,
	label: "TLS",
	type: :boolean,
	description: "Enable to use STARTTLS, usually implies the port 389"
	},
	%{
	key: :tlsopts,
	label: "TLS options",
	type: :keyword,
	description: "Additional TLS options",
	suggestions: [verify: :verify_peer],
	children: [
	%{
	key: :verify,
	type: :atom,
	description: "Type of cert verification",
	suggestions: [:verify_peer]
	}
	]
	},
	%{
	key: :base,
	type: :string,
	description: "LDAP base, e.g. \"dc=example,dc=com\"",
	suggestions: ["dc=example,dc=com"]
	},
	%{
	key: :uid,
	label: "UID Attribute",
	type: :string,
	description:
	"LDAP attribute name to authenticate the user, e.g. when \"cn\", the filter will be \"cn=username,base\"",
	suggestions: ["cn"]
	},
	%{
	key: :cacertfile,
	label: "CACertfile",
	type: :string,
	description: "Path to CA certificate file"
	},
	%{
	key: :mail,
	label: "Mail Attribute",
	type: :string,
	description:
	"LDAP attribute name to use as the email address when automatically registering the user on first login",
	suggestions: ["mail"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :auth,
	type: :group,
	description: "Authentication / authorization settings",
	children: [
	%{
	key: :enforce_oauth_admin_scope_usage,
	label: "Enforce OAuth admin scope usage",
	type: :boolean,
	description:
	"OAuth admin scope requirement toggle. " <>
	"If enabled, admin actions explicitly demand admin OAuth scope(s) presence in OAuth token " <>
	"(client app must support admin scopes). If disabled and token doesn't have admin scope(s), " <>
	"`is_admin` user flag grants access to admin-specific actions."
	},
	%{
	key: :auth_template,
	type: :string,
	description:
	"Authentication form template. By default it's `show.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/show.html.ee`.",
	suggestions: ["show.html"]
	},
	%{
	key: :oauth_consumer_template,
	label: "OAuth consumer template",
	type: :string,
	description:
	"OAuth consumer mode authentication form template. By default it's `consumer.html` which corresponds to" <>
	" `lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex`.",
	suggestions: ["consumer.html"]
	},
	%{
	key: :oauth_consumer_strategies,
	label: "OAuth consumer strategies",
	type: {:list, :string},
	description:
	"The list of enabled OAuth consumer strategies. By default it's set by OAUTH_CONSUMER_STRATEGIES environment variable." <>
	" Each entry in this space-delimited string should be of format \"strategy\" or \"strategy:dependency\"" <>
	" (e.g. twitter or keycloak:ueberauth_keycloak_strategy in case dependency is named differently than ueberauth_<strategy>).",
	suggestions: ["twitter", "keycloak:ueberauth_keycloak_strategy"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :email_notifications,
	type: :group,
	description: "Email notifications settings",
	children: [
	%{
	key: :digest,
	type: :map,
	description:
	"emails of \"what you've missed\" for users who have been inactive for a while",
	suggestions: [
	%{
	active: false,
	schedule: "0 0 * * 0",
	interval: 7,
	inactivity_threshold: 7
	}
	],
	children: [
	%{
	key: :active,
	label: "Enabled",
	type: :boolean,
	description: "Globally enable or disable digest emails"
	},
	%{
	key: :schedule,
	type: :string,
	description:
	"When to send digest email, in crontab format. \"0 0 0\" is the default, meaning \"once a week at midnight on Sunday morning\".",
	suggestions: ["0 0 * * 0"]
	},
	%{
	key: :interval,
	type: :integer,
	description: "Minimum interval between digest emails to one user",
	suggestions: [7]
	},
	%{
	key: :inactivity_threshold,
	type: :integer,
	description: "Minimum user inactivity threshold",
	suggestions: [7]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.UserEmail,
	type: :group,
	description: "Email template settings",
	children: [
	%{
	key: :logo,
	type: {:string, :image},
	description: "A path to a custom logo. Set it to `nil` to use the default Pleroma logo.",
	suggestions: ["some/path/logo.png"]
	},
	%{
	key: :styling,
	type: :map,
	description: "A map with color settings for email templates.",
	suggestions: [
	%{
	link_color: "#d8a070",
	background_color: "#2C3645",
	content_background_color: "#1B2635",
	header_color: "#d8a070",
	text_color: "#b9b9ba",
	text_muted_color: "#b9b9ba"
	}
	],
	children: [
	%{
	key: :link_color,
	type: :string,
	suggestions: ["#d8a070"]
	},
	%{
	key: :background_color,
	type: :string,
	suggestions: ["#2C3645"]
	},
	%{
	key: :content_background_color,
	type: :string,
	suggestions: ["#1B2635"]
	},
	%{
	key: :header_color,
	type: :string,
	suggestions: ["#d8a070"]
	},
	%{
	key: :text_color,
	type: :string,
	suggestions: ["#b9b9ba"]
	},
	%{
	key: :text_muted_color,
	type: :string,
	suggestions: ["#b9b9ba"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Emails.NewUsersDigestEmail,
	type: :group,
	description: "New users admin email digest",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables new users admin digest email when `true`"
	}
	]
	},
	%{
	group: :pleroma,
	key: :oauth2,
	label: "OAuth2",
	type: :group,
	description: "Configure OAuth 2 provider capabilities",
	children: [
	%{
	key: :token_expires_in,
	type: :integer,
	description: "The lifetime in seconds of the access token",
	suggestions: [2_592_000]
	},
	%{
	key: :issue_new_refresh_token,
	type: :boolean,
	description:
	"Keeps old refresh token or generate new refresh token when to obtain an access token"
	},
	%{
	key: :clean_expired_tokens,
	type: :boolean,
	description: "Enable a background job to clean expired OAuth tokens. Default: disabled."
	}
	]
	},
	%{
	group: :pleroma,
	key: :emoji,
	type: :group,
	children: [
	%{
	key: :shortcode_globs,
	type: {:list, :string},
	description: "Location of custom emoji files. * can be used as a wildcard.",
	suggestions: ["/emoji/custom/*/.png"]
	},
	%{
	key: :pack_extensions,
	type: {:list, :string},
	description:
	"A list of file extensions for emojis, when no emoji.txt for a pack is present",
	suggestions: [".png", ".gif"]
	},
	%{
	key: :groups,
	type: {:keyword, {:list, :string}},
	description:
	"Emojis are ordered in groups (tags). This is an array of key-value pairs where the key is the group name" <>
	" and the value is the location or array of locations. * can be used as a wildcard.",
	suggestions: [
	Custom: ["/emoji/.png", "/emoji//.png"]
	]
	},
	%{
	key: :default_manifest,
	type: :string,
	description:
	"Location of the JSON-manifest. This manifest contains information about the emoji-packs you can download." <>
	" Currently only one manifest can be added (no arrays).",
	suggestions: ["https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"]
	},
	%{
	key: :shared_pack_cache_seconds_per_file,
	label: "Shared pack cache s/file",
	type: :integer,
	descpiption:
	"When an emoji pack is shared, the archive is created and cached in memory" <>
	" for this amount of seconds multiplied by the number of files.",
	suggestions: [60]
	}
	]
	},
	%{
	group: :pleroma,
	key: :rate_limit,
	type: :group,
	description:
	"Rate limit settings. This is an advanced feature enabled only for :authentication by default.",
	children: [
	%{
	key: :search,
	type: [:tuple, {:list, :tuple}],
	description: "For the search requests (account & status search etc.)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :timeline,
	type: [:tuple, {:list, :tuple}],
	description: "For requests to timelines (each timeline has it's own limiter)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :app_account_creation,
	type: [:tuple, {:list, :tuple}],
	description: "For registering user accounts from the same IP address",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :relations_actions,
	type: [:tuple, {:list, :tuple}],
	description: "For actions on relationships with all users (follow, unfollow)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :relation_id_action,
	label: "Relation ID action",
	type: [:tuple, {:list, :tuple}],
	description: "For actions on relation with a specific user (follow, unfollow)",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :statuses_actions,
	type: [:tuple, {:list, :tuple}],
	description:
	"For create / delete / fav / unfav / reblog / unreblog actions on any statuses",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :status_id_action,
	label: "Status ID action",
	type: [:tuple, {:list, :tuple}],
	description:
	"For fav / unfav or reblog / unreblog actions on the same status by the same user",
	suggestions: [{1000, 10}, [{10_000, 10}, {10_000, 50}]]
	},
	%{
	key: :authentication,
	type: [:tuple, {:list, :tuple}],
	description: "For authentication create / password check / user existence check requests",
	suggestions: [{60_000, 15}]
	}
	]
	},
	%{
	group: :mime,
	label: "Mime Types",
	type: :group,
	description: "Mime Types settings",
	children: [
	%{
	key: :types,
	type: :map,
	suggestions: [
	%{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"application/jrd+json" => ["jrd+json"],
	"application/activity+json" => ["activity+json"],
	"application/ld+json" => ["activity+json"]
	}
	],
	children: [
	%{
	key: "application/xml",
	type: {:list, :string},
	suggestions: ["xml"]
	},
	%{
	key: "application/xrd+xml",
	type: {:list, :string},
	suggestions: ["xrd+xml"]
	},
	%{
	key: "application/jrd+json",
	type: {:list, :string},
	suggestions: ["jrd+json"]
	},
	%{
	key: "application/activity+json",
	type: {:list, :string},
	suggestions: ["activity+json"]
	},
	%{
	key: "application/ld+json",
	type: {:list, :string},
	suggestions: ["activity+json"]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :shout,
	type: :group,
	description: "Pleroma shout settings",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables the backend Shoutbox chat feature."
	},
	%{
	key: :limit,
	type: :integer,
	description: "Shout message character limit.",
	suggestions: [
	5_000
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :http,
	label: "HTTP",
	type: :group,
	description: "HTTP settings",
	children: [
	%{
	key: :proxy_url,
	label: "Proxy URL",
	type: [:string, :tuple],
	description: "Proxy URL",
	suggestions: ["localhost:9020", {:socks5, :localhost, 3090}]
	},
	%{
	key: :send_user_agent,
	type: :boolean
	},
	%{
	key: :user_agent,
	type: [:string, :atom],
	description:
	"What user agent to use. Must be a string or an atom `:default`. Default value is `:default`.",
	suggestions: ["Pleroma", :default]
	},
	%{
	key: :adapter,
	type: :keyword,
	description: "Adapter specific options",
	suggestions: [],
	children: [
	%{
	key: :ssl_options,
	type: :keyword,
	label: "SSL Options",
	description: "SSL options for HTTP adapter",
	children: [
	%{
	key: :versions,
	type: {:list, :atom},
	description: "List of TLS version to use",
	suggestions: [:tlsv1, ":tlsv1.1", ":tlsv1.2", ":tlsv1.3"]
	}
	]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :markup,
	label: "Markup Settings",
	type: :group,
	children: [
	%{
	key: :allow_inline_images,
	type: :boolean
	},
	%{
	key: :allow_headings,
	type: :boolean
	},
	%{
	key: :allow_tables,
	type: :boolean
	},
	%{
	key: :allow_fonts,
	type: :boolean
	},
	%{
	key: :scrub_policy,
	type: {:list, :module},
	description:
	"Module names are shortened (removed leading `Pleroma.HTML.` part), but on adding custom module you need to use full name.",
	suggestions: [Pleroma.HTML.Transform.MediaProxy, Pleroma.HTML.Scrubber.Default]
	}
	]
	},
	%{
	group: :pleroma,
	key: :user,
	type: :group,
	children: [
	%{
	key: :deny_follow_blocked,
	type: :boolean
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.User,
	type: :group,
	children: [
	%{
	key: :restricted_nicknames,
	type: {:list, :string},
	description: "List of nicknames users may not register with.",
	suggestions: [
	".well-known",
	"~",
	"about",
	"activities",
	"api",
	"auth",
	"check_password",
	"dev",
	"friend-requests",
	"inbox",
	"internal",
	"main",
	"media",
	"nodeinfo",
	"notice",
	"oauth",
	"objects",
	"ostatus_subscribe",
	"pleroma",
	"proxy",
	"push",
	"registration",
	"relay",
	"settings",
	"status",
	"tag",
	"user-search",
	"user_exists",
	"users",
	"web"
	]
	},
	%{
	key: :email_blacklist,
	type: {:list, :string},
	description: "List of email domains users may not register with.",
	suggestions: ["mailinator.com", "maildrop.cc"]
	}
	]
	},
	%{
	group: :cors_plug,
	label: "CORS plug config",
	type: :group,
	children: [
	%{
	key: :max_age,
	type: :integer,
	suggestions: [86_400]
	},
	%{
	key: :methods,
	type: {:list, :string},
	suggestions: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"]
	},
	%{
	key: :expose,
	type: {:list, :string},
	suggestions: [
	"Link",
	"X-RateLimit-Reset",
	"X-RateLimit-Limit",
	"X-RateLimit-Remaining",
	"X-Request-Id",
	"Idempotency-Key"
	]
	},
	%{
	key: :credentials,
	type: :boolean
	},
	%{
	key: :headers,
	type: {:list, :string},
	suggestions: ["Authorization", "Content-Type", "Idempotency-Key"]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.Plugs.RemoteIp,
	type: :group,
	description: """
	`Pleroma.Web.Plugs.RemoteIp` is a shim to call [`RemoteIp`](https://git.pleroma.social/pleroma/remote_ip) but with runtime configuration.
	If your instance is not behind at least one reverse proxy, you should not enable this plug.
	""",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enable/disable the plug. Default: disabled."
	},
	%{
	key: :headers,
	type: {:list, :string},
	description: """
	A list of strings naming the HTTP headers to use when deriving the true client IP. Default: `["x-forwarded-for"]`.
	"""
	},
	%{
	key: :proxies,
	type: {:list, :string},
	description:
	"A list of upstream proxy IP subnets in CIDR notation from which we will parse the content of `headers`. Defaults to `[]`. IPv4 entries without a bitmask will be assumed to be /32 and IPv6 /128."
	},
	%{
	key: :reserved,
	type: {:list, :string},
	description: """
	A list of reserved IP subnets in CIDR notation which should be ignored if found in `headers`. Defaults to `["127.0.0.0/8", "::1/128", "fc00::/7", "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]`
	"""
	}
	]
	},
	%{
	group: :pleroma,
	key: :web_cache_ttl,
	label: "Web cache TTL",
	type: :group,
	description:
	"The expiration time for the web responses cache. Values should be in milliseconds or `nil` to disable expiration.",
	children: [
	%{
	key: :activity_pub,
	type: :integer,
	description:
	"Activity pub routes (except question activities). Default: `nil` (no expiration).",
	suggestions: [nil]
	},
	%{
	key: :activity_pub_question,
	type: :integer,
	description: "Activity pub routes (question activities). Default: `30_000` (30 seconds).",
	suggestions: [30_000]
	}
	]
	},
	%{
	group: :pleroma,
	key: :static_fe,
	label: "Static FE",
	type: :group,
	description:
	"Render profiles and posts using server-generated HTML that is viewable without using JavaScript",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Enables the rendering of static HTML. Default: disabled."
	}
	]
	},
	%{
	group: :pleroma,
	key: :feed,
	type: :group,
	description: "Configure feed rendering",
	children: [
	%{
	key: :post_title,
	type: :map,
	description: "Configure title rendering",
	children: [
	%{
	key: :max_length,
	type: :integer,
	description: "Maximum number of characters before truncating title",
	suggestions: [100]
	},
	%{
	key: :omission,
	type: :string,
	description: "Replacement which will be used after truncating string",
	suggestions: ["..."]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :mrf_follow_bot,
	tab: :mrf,
	related_policy: "Pleroma.Web.ActivityPub.MRF.FollowBotPolicy",
	label: "MRF FollowBot Policy",
	type: :group,
	description: "Automatically follows newly discovered accounts.",
	children: [
	%{
	key: :follower_nickname,
	type: :string,
	description: "The name of the bot account to use for following newly discovered users.",
	suggestions: ["followbot"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :modules,
	type: :group,
	description: "Custom Runtime Modules",
	children: [
	%{
	key: :runtime_dir,
	type: :string,
	description: "A path to custom Elixir modules (such as MRF policies)."
	}
	]
	},
	%{
	group: :pleroma,
	key: :streamer,
	type: :group,
	description: "Settings for notifications streamer",
	children: [
	%{
	key: :workers,
	type: :integer,
	description: "Number of workers to send notifications",
	suggestions: [3]
	},
	%{
	key: :overflow_workers,
	type: :integer,
	description: "Maximum number of workers created if pool is empty",
	suggestions: [2]
	}
	]
	},
	%{
	group: :pleroma,
	key: :connections_pool,
	type: :group,
	description: "Advanced settings for `Gun` connections pool",
	children: [
	%{
	key: :connection_acquisition_wait,
	type: :integer,
	description:
	"Timeout to acquire a connection from pool. The total max time is this value multiplied by the number of retries. Default: 250ms.",
	suggestions: [250]
	},
	%{
	key: :connection_acquisition_retries,
	type: :integer,
	description:
	"Number of attempts to acquire the connection from the pool if it is overloaded. Default: 5",
	suggestions: [5]
	},
	%{
	key: :max_connections,
	type: :integer,
	description: "Maximum number of connections in the pool. Default: 250 connections.",
	suggestions: [250]
	},
	%{
	key: :connect_timeout,
	type: :integer,
	description: "Timeout while `gun` will wait until connection is up. Default: 5000ms.",
	suggestions: [5000]
	},
	%{
	key: :reclaim_multiplier,
	type: :integer,
	description:
	"Multiplier for the number of idle connection to be reclaimed if the pool is full. For example if the pool maxes out at 250 connections and this setting is set to 0.3, the pool will reclaim at most 75 idle connections if it's overloaded. Default: 0.1",
	suggestions: [0.1]
	}
	]
	},
	%{
	group: :pleroma,
	key: :pools,
	type: :group,
	description: "Advanced settings for `Gun` workers pools",
	children:
	Enum.map([:federation, :media, :upload, :default], fn pool_name ->
	%{
	key: pool_name,
	type: :keyword,
	description: "Settings for #{pool_name} pool.",
	children: [
	%{
	key: :size,
	type: :integer,
	description: "Maximum number of concurrent requests in the pool.",
	suggestions: [50]
	},
	%{
	key: :max_waiting,
	type: :integer,
	description:
	"Maximum number of requests waiting for other requests to finish. After this number is reached, the pool will start returning errors when a new request is made",
	suggestions: [10]
	},
	%{
	key: :recv_timeout,
	type: :integer,
	description: "Timeout for the pool while gun will wait for response",
	suggestions: [10_000]
	}
	]
	}
	end)
	},
	%{
	group: :pleroma,
	key: :hackney_pools,
	type: :group,
	description: "Advanced settings for `Hackney` connections pools",
	children: [
	%{
	key: :federation,
	type: :keyword,
	description: "Settings for federation pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [50]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [150_000]
	}
	]
	},
	%{
	key: :media,
	type: :keyword,
	description: "Settings for media pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [50]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [150_000]
	}
	]
	},
	%{
	key: :upload,
	type: :keyword,
	description: "Settings for upload pool.",
	children: [
	%{
	key: :max_connections,
	type: :integer,
	description: "Number workers in the pool.",
	suggestions: [25]
	},
	%{
	key: :timeout,
	type: :integer,
	description: "Timeout while `hackney` will wait for response.",
	suggestions: [300_000]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :restrict_unauthenticated,
	label: "Restrict Unauthenticated",
	type: :group,
	description:
	"Disallow viewing timelines, user profiles and statuses for unauthenticated users.",
	children: [
	%{
	key: :timelines,
	type: :map,
	description: "Settings for public and federated timelines.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view public timeline."
	},
	%{
	key: :federated,
	type: :boolean,
	description: "Disallow view federated timeline."
	}
	]
	},
	%{
	key: :profiles,
	type: :map,
	description: "Settings for user profiles.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view local user profiles."
	},
	%{
	key: :remote,
	type: :boolean,
	description: "Disallow view remote user profiles."
	}
	]
	},
	%{
	key: :activities,
	type: :map,
	description: "Settings for statuses.",
	children: [
	%{
	key: :local,
	type: :boolean,
	description: "Disallow view local statuses."
	},
	%{
	key: :remote,
	type: :boolean,
	description: "Disallow view remote statuses."
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.ApiSpec.CastAndValidate,
	type: :group,
	children: [
	%{
	key: :strict,
	type: :boolean,
	description:
	"Enables strict input validation (useful in development, not recommended in production)"
	}
	]
	},
	%{
	group: :pleroma,
	key: :instances_favicons,
	type: :group,
	description: "Control favicons for instances",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "Allow/disallow displaying and getting instances favicons"
	}
	]
	},
	%{
	group: :ex_aws,
	key: :s3,
	type: :group,
	descriptions: "S3 service related settings",
	children: [
	%{
	key: :access_key_id,
	type: :string,
	description: "S3 access key ID",
	suggestions: ["AKIAQ8UKHTGIYN7DMWWJ"]
	},
	%{
	key: :secret_access_key,
	type: :string,
	description: "Secret access key",
	suggestions: ["JFGt+fgH1UQ7vLUQjpW+WvjTdV/UNzVxcwn7DkaeFKtBS5LvoXvIiME4NQBsT6ZZ"]
	},
	%{
	key: :host,
	type: :string,
	description: "S3 host",
	suggestions: ["s3.eu-central-1.amazonaws.com"]
	},
	%{
	key: :region,
	type: :string,
	description: "S3 region (for AWS)",
	suggestions: ["us-east-1"]
	}
	]
	},
	%{
	group: :pleroma,
	key: :frontends,
	type: :group,
	description: "Installed frontends management",
	children: [
	%{
	key: :primary,
	type: :map,
	description: "Primary frontend, the one that is served for all pages by default",
	children: installed_frontend_options
	},
	%{
	key: :admin,
	type: :map,
	description: "Admin frontend",
	children: installed_frontend_options
	},
	%{
	key: :available,
	type: :map,
	description:
	"A map containing available frontends and parameters for their installation.",
	children: frontend_options
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Web.Preload,
	type: :group,
	description: "Preload-related settings",
	children: [
	%{
	key: :providers,
	type: {:list, :module},
	description: "List of preload providers to enable",
	suggestions: [
	Pleroma.Web.Preload.Providers.Instance,
	Pleroma.Web.Preload.Providers.User,
	Pleroma.Web.Preload.Providers.Timelines
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: :majic_pool,
	type: :group,
	description: "Majic/libmagic configuration",
	children: [
	%{
	key: :size,
	type: :integer,
	description: "Number of majic workers to start.",
	suggestions: [2]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.User.Backup,
	type: :group,
	description: "Account Backup",
	children: [
	%{
	key: :purge_after_days,
	type: :integer,
	description: "Remove backup archives after N days",
	suggestions: [30]
	},
	%{
	key: :limit_days,
	type: :integer,
	description: "Limit user to export not more often than once per N days",
	suggestions: [7]
	},
	%{
	key: :process_chunk_size,
	type: :integer,
	label: "Process Chunk Size",
	description: "The number of activities to fetch in the backup job for each chunk.",
	suggestions: [100]
	},
	%{
	key: :timeout,
	type: :integer,
	label: "Timeout",
	description: "The amount of time to wait for backup to complete in seconds.",
	suggestions: [1_800]
	}
	]
	},
	%{
	group: :prometheus,
	key: Pleroma.Web.Endpoint.MetricsExporter,
	type: :group,
	description: "Prometheus app metrics endpoint configuration",
	children: [
	%{
	key: :enabled,
	type: :boolean,
	description: "[Pleroma extension] Enables app metrics endpoint."
	},
	%{
	key: :ip_whitelist,
	label: "IP Whitelist",
	type: [{:list, :string}, {:list, :charlist}, {:list, :tuple}],
	description: "Restrict access of app metrics endpoint to the specified IP addresses."
	},
	%{
	key: :auth,
	type: [:boolean, :tuple],
	description: "Enables HTTP Basic Auth for app metrics endpoint.",
	suggestion: [false, {:basic, "myusername", "mypassword"}]
	},
	%{
	key: :path,
	type: :string,
	description: "App metrics endpoint URI path.",
	suggestions: ["/api/pleroma/app_metrics"]
	},
	%{
	key: :format,
	type: :atom,
	description: "App metrics endpoint output format.",
	suggestions: [:text, :protobuf]
	}
	]
	},
	%{
	group: :pleroma,
	key: ConcurrentLimiter,
	type: :group,
	description: "Limits configuration for background tasks.",
	children: [
	%{
	key: Pleroma.Web.RichMedia.Helpers,
	type: :keyword,
	description: "Concurrent limits configuration for getting RichMedia for activities.",
	suggestions: [max_running: 5, max_waiting: 5],
	children: [
	%{
	key: :max_running,
	type: :integer,
	description: "Max running concurrently jobs.",
	suggestion: [5]
	},
	%{
	key: :max_waiting,
	type: :integer,
	description: "Max waiting jobs.",
	suggestion: [5]
	}
	]
	},
	%{
	key: Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy,
	type: :keyword,
	description: "Concurrent limits configuration for MediaProxyWarmingPolicy.",
	suggestions: [max_running: 5, max_waiting: 5],
	children: [
	%{
	key: :max_running,
	type: :integer,
	description: "Max running concurrently jobs.",
	suggestion: [5]
	},
	%{
	key: :max_waiting,
	type: :integer,
	description: "Max waiting jobs.",
	suggestion: [5]
	}
	]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Search,
	type: :group,
	description: "General search settings.",
	children: [
	%{
	key: :module,
	type: :keyword,
	description: "Selected search module.",
	suggestion: [Pleroma.Search.DatabaseSearch, Pleroma.Search.Meilisearch]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Search.Meilisearch,
	type: :group,
	description: "Meilisearch settings.",
	children: [
	%{
	key: :url,
	type: :string,
	description: "Meilisearch URL.",
	suggestion: ["http://127.0.0.1:7700/"]
	},
	%{
	key: :private_key,
	type: :string,
	description:
	"Private key for meilisearch authentication, or `nil` to disable private key authentication.",
	suggestion: [nil]
	},
	%{
	key: :initial_indexing_chunk_size,
	type: :integer,
	description:
	"Amount of posts in a batch when running the initial indexing operation. Should probably not be more than 100000" <>
	" since there's a limit on maximum insert size",
	suggestion: [100_000]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Language.LanguageDetector,
	type: :group,
	description: "Language detection providers",
	children: [
	%{
	key: :provider,
	type: :module,
	suggestions: [
	Pleroma.Language.LanguageDetector.Fasttext
	]
	},
	%{
	group: {:subgroup, Pleroma.Language.LanguageDetector.Fasttext},
	key: :model,
	label: "fastText language detection model",
	type: :string,
	suggestions: ["/usr/share/fasttext/lid.176.bin"]
	}
	]
	},
	%{
	group: :pleroma,
	key: Pleroma.Language.Translation,
	type: :group,
	description: "Translation providers",
	children: [
	%{
	key: :provider,
	type: :module,
	suggestions: [
	Pleroma.Language.Translation.Deepl,
	Pleroma.Language.Translation.Libretranslate,
	+ Pleroma.Language.Translation.Mozhi,
	Pleroma.Language.Translation.TranslateLocally
	]
	},
	%{
	group: {:subgroup, Pleroma.Language.Translation.Deepl},
	key: :base_url,
	label: "DeepL base URL",
	type: :string,
	suggestions: ["https://api-free.deepl.com", "https://api.deepl.com"]
	},
	%{
	group: {:subgroup, Pleroma.Language.Translation.Deepl},
	key: :api_key,
	label: "DeepL API Key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Pleroma.Language.Translation.Libretranslate},
	key: :base_url,
	label: "LibreTranslate instance URL",
	type: :string,
	suggestions: ["https://libretranslate.com"]
	},
	%{
	group: {:subgroup, Pleroma.Language.Translation.Libretranslate},
	key: :api_key,
	label: "LibreTranslate API Key",
	type: :string,
	suggestions: ["YOUR_API_KEY"]
	},
	%{
	group: {:subgroup, Pleroma.Language.Translation.TranslateLocally},
	- key: :intermediate_language,
	+ key: :intermediary_language,
	label:
	- "translateLocally intermediate language (used when direct source->target model is not available)",
	+ "translateLocally intermediary language (used when direct source->target model is not available)",
	type: :string,
	suggestions: ["en"]
	+ },
	+ %{
	+ group: {:subgroup, Pleroma.Language.Translation.Mozhi},
	+ key: :base_url,
	+ label: "Mozhi instance URL",
	+ type: :string
	+ },
	+ %{
	+ group: {:subgroup, Pleroma.Language.Translation.Mozhi},
	+ key: :engine,
	+ label: "Engine used for Mozhi",
	+ type: :string,
	+ suggestions: ["libretranslate"]
	}
	]
	}
	]
	diff --git a/docs/development/API/differences_in_mastoapi_responses.md b/docs/development/API/differences_in_mastoapi_responses.md
	index 4326c4255..fa7e3e5ab 100644
	--- a/docs/development/API/differences_in_mastoapi_responses.md
	+++ b/docs/development/API/differences_in_mastoapi_responses.md
	@@ -1,523 +1,529 @@
	# Differences in Mastodon API responses from vanilla Mastodon

	A Pleroma instance can be identified by "<Mastodon version> (compatible; Pleroma <version>)" present in `version` field in response from `/api/v1/instance` and `/api/v2/instance`

	## Flake IDs

	Pleroma uses 128-bit ids as opposed to Mastodon's 64 bits. However, just like Mastodon's ids, they are lexically sortable strings

	## Timelines

	Adding the parameter `with_muted=true` to the timeline queries will also return activities by muted (not by blocked!) users.

	Adding the parameter `exclude_visibilities` to the timeline queries will exclude the statuses with the given visibilities. The parameter accepts an array of visibility types (`public`, `unlisted`, `private`, `direct`), e.g., `exclude_visibilities[]=direct&exclude_visibilities[]=private`.

	Adding the parameter `reply_visibility` to the public and home timelines queries will filter replies. Possible values: without parameter (default) shows all replies, `following` - replies directed to you or users you follow, `self` - replies directed to you.

	Adding the parameter `instance=lain.com` to the public timeline will show only statuses originating from `lain.com` (or any remote instance).

	Home, public, hashtag & list timelines accept these parameters:

	- `only_media`: show only statuses with media attached
	- `local`: show only local statuses
	- `remote`: show only remote statuses

	## Statuses

	- `visibility`: has additional possible values `list` and `local` (for local-only statuses)

	Has these additional fields under the `pleroma` object:

	- `local`: true if the post was made on the local instance
	- `conversation_id`: the ID of the AP context the status is associated with (if any)
	- `direct_conversation_id`: the ID of the Mastodon direct message conversation the status is associated with (if any)
	- `in_reply_to_account_acct`: the `acct` property of User entity for replied user (if any)
	- `content`: a map consisting of alternate representations of the `content` property with the key being its mimetype. Currently, the only alternate representation supported is `text/plain`
	- `spoiler_text`: a map consisting of alternate representations of the `spoiler_text` property with the key being its mimetype. Currently, the only alternate representation supported is `text/plain`
	- `expires_at`: a datetime (iso8601) that states when the post will expire (be deleted automatically), or empty if the post won't expire
	- `thread_muted`: true if the thread the post belongs to is muted
	- `emoji_reactions`: A list with emoji / reaction maps. The format is `{name: "☕", count: 1, me: true}`. Contains no information about the reacting users, for that use the `/statuses/:id/reactions` endpoint.
	- `parent_visible`: If the parent of this post is visible to the user or not.
	- `pinned_at`: a datetime (iso8601) when status was pinned, `null` otherwise.
	- `quotes_count`: the count of status quotes.
	-- `non_anonymous`: true if the source post specifies the poll results are not anonymous. Currently only implemented by Smithereen.
	- `bookmark_folder`: the ID of the folder bookmark is stored within (if any).
	- `list_id`: the ID of the list the post is addressed to (if any, only returned to author).

	+Has these additional fields under the `poll.pleroma` object:
	+
	+- `non_anonymous`: true if the source post specifies the poll results are not anonymous. Currently only implemented by Smithereen.
	+
	The `GET /api/v1/statuses/:id/source` endpoint additionally has the following attributes:

	- `content_type`: The content type of the status source.

	## Scheduled statuses

	Has these additional fields in `params`:

	- `expires_in`: the number of seconds the posted activity should expire in.

	## Media Attachments

	Has these additional fields under the `pleroma` object:

	- `mime_type`: mime type of the attachment.

	### Attachment cap

	Some apps operate under the assumption that no more than 4 attachments can be returned or uploaded. Pleroma however does not enforce any limits on attachment count neither when returning the status object nor when posting.

	### Limitations

	Pleroma does not process remote images and therefore cannot include fields such as `meta` and `blurhash`. It does not support focal points or aspect ratios. The frontend is expected to handle it.

	## Bookmarks

	The `GET /api/v1/bookmarks` endpoint accepts optional parameter `folder_id` for bookmark folder ID.

	The `POST /api/v1/statuses/:id/bookmark` endpoint accepts optional parameter `folder_id` for bookmark folder ID.

	## Accounts

	The `id` parameter can also be the `nickname` of the user. This only works in these endpoints, not the deeper nested ones for following etc.

	- `/api/v1/accounts/:id`
	- `/api/v1/accounts/:id/statuses`

	`/api/v1/accounts/:id/statuses` endpoint accepts these parameters:

	- `pinned`: include only pinned statuses
	- `tagged`: with tag
	- `only_media`: include only statuses with media attached
	- `with_muted`: include statuses/reactions from muted accounts
	- `exclude_reblogs`: exclude reblogs
	- `only_reblogs`: include only reblogs
	- `exclude_replies`: exclude replies
	- `exclude_visibilities`: exclude visibilities

	Endpoints which accept `with_relationships` parameter:

	- `/api/v1/accounts/:id`
	- `/api/v1/accounts/:id/followers`
	- `/api/v1/accounts/:id/following`
	- `/api/v1/mutes`
	+- `/api/v1/blocks`
	+- `/api/v1/search`
	+- `/api/v2/search`

	Has these additional fields under the `pleroma` object:

	- `ap_id`: nullable URL string, ActivityPub id of the user
	- `background_image`: nullable URL string, background image of the user
	- `tags`: Lists an array of tags for the user
	- `relationship` (object): Includes fields as documented for Mastodon API https://docs.joinmastodon.org/entities/relationship/
	- `is_moderator`: boolean, nullable, true if user is a moderator
	- `is_admin`: boolean, nullable, true if user is an admin
	- `confirmation_pending`: boolean, true if a new user account is waiting on email confirmation to be activated
	- `hide_favorites`: boolean, true when the user has hiding favorites enabled
	- `hide_followers`: boolean, true when the user has follower hiding enabled
	- `hide_follows`: boolean, true when the user has follow hiding enabled
	- `hide_followers_count`: boolean, true when the user has follower stat hiding enabled
	- `hide_follows_count`: boolean, true when the user has follow stat hiding enabled
	- `settings_store`: A generic map of settings for frontends. Opaque to the backend. Only returned in `/api/v1/accounts/verify_credentials` and `/api/v1/accounts/update_credentials`
	- `chat_token`: The token needed for Pleroma shoutbox. Only returned in `/api/v1/accounts/verify_credentials`
	- `deactivated`: boolean, true when the user is deactivated
	- `allow_following_move`: boolean, true when the user allows automatically follow moved following accounts
	- `unread_conversation_count`: The count of unread conversations. Only returned to the account owner.
	- `unread_notifications_count`: The count of unread notifications. Only returned to the account owner.
	- `notification_settings`: object, can be absent. See `/api/v1/pleroma/notification_settings` for the parameters/keys returned.
	- `accepts_chat_messages`: boolean, but can be null if we don't have that information about a user
	- `favicon`: nullable URL string, Favicon image of the user's instance
	- `avatar_description`: string, image description for user avatar, defaults to empty string
	- `header_description`: string, image description for user banner, defaults to empty string

	### Source

	Has these additional fields under the `pleroma` object:

	- `show_role`: boolean, nullable, true when the user wants his role (e.g admin, moderator) to be shown
	- `no_rich_text` - boolean, nullable, true when html tags are stripped from all statuses requested from the API
	- `discoverable`: boolean, true when the user allows external services (search bots) etc. to index / list the account (regardless of this setting, user will still appear in regular search results)
	- `actor_type`: string, the type of this account.

	## Conversations

	Has an additional field under the `pleroma` object:

	- `recipients`: The list of the recipients of this Conversation. These will be addressed when replying to this conversation.

	## GET `/api/v1/conversations`

	Accepts additional parameters:

	- `recipients`: Only return conversations with the given recipients (a list of user ids). Usage example: `GET /api/v1/conversations?recipients[]=1&recipients[]=2`

	## Account Search

	Behavior has changed:

	- `/api/v1/accounts/search`: Does not require authentication

	## Search (global)

	Unlisted posts are available in search results, they are considered to be public posts that shouldn't be shown in local/federated timeline.

	## Notifications

	Has these additional fields under the `pleroma` object:

	- `is_seen`: true if the notification was read by the user

	### Move Notification

	The `type` value is `move`. Has an additional field:

	- `target`: new account

	### EmojiReact Notification

	The `type` value is `pleroma:emoji_reaction`. Has these fields:

	- `emoji`: The used emoji
	- `account`: The account of the user who reacted
	- `status`: The status that was reacted on

	### ChatMention Notification (not default)

	This notification has to be requested explicitly.

	The `type` value is `pleroma:chat_mention`

	- `account`: The account who sent the message
	- `chat_message`: The chat message

	### Report Notification (not default)

	This notification has to be requested explicitly.

	The `type` value is `pleroma:report`

	- `account`: The account who reported
	- `report`: The report

	## GET `/api/v1/notifications`

	Accepts additional parameters:

	- `exclude_visibilities`: will exclude the notifications for activities with the given visibilities. The parameter accepts an array of visibility types (`public`, `unlisted`, `private`, `direct`). Usage example: `GET /api/v1/notifications?exclude_visibilities[]=direct&exclude_visibilities[]=private`.
	- `include_types`: will include the notifications for activities with the given types. The parameter accepts an array of types (`mention`, `follow`, `reblog`, `favourite`, `move`, `pleroma:emoji_reaction`, `pleroma:chat_mention`, `pleroma:report`). Usage example: `GET /api/v1/notifications?include_types[]=mention&include_types[]=reblog`.

	## DELETE `/api/v1/notifications/destroy_multiple`

	An endpoint to delete multiple statuses by IDs.

	Required parameters:

	- `ids`: array of activity ids

	Usage example: `DELETE /api/v1/notifications/destroy_multiple/?ids[]=1&ids[]=2`.

	Returns on success: 200 OK `{}`

	## POST `/api/v1/statuses`

	Additional parameters can be added to the JSON body/Form data:

	- `preview`: boolean, if set to `true` the post won't be actually posted, but the status entity would still be rendered back. This could be useful for previewing rich text/custom emoji, for example.
	- `content_type`: string, contain the MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint.
	- `to`: A list of nicknames (like `lain@soykaf.club` or `lain` on the local server) that will be used to determine who is going to be addressed by this post. Using this will disable the implicit addressing by mentioned names in the `status` body, only the people in the `to` list will be addressed. The normal rules for post visibility are not affected by this and will still apply.
	- `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted`, `local` or `public`) it can be used to address a List by setting it to `list:LIST_ID`.
	- `expires_in`: The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour.
	- `in_reply_to_conversation_id`: Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`.

	## GET `/api/v1/statuses`

	An endpoint to get multiple statuses by IDs.

	Required parameters:

	- `ids`: array of activity ids

	Usage example: `GET /api/v1/statuses/?ids[]=1&ids[]=2`.

	Returns: array of Status.

	The maximum number of statuses is limited to 100 per request.

	## PATCH `/api/v1/accounts/update_credentials`

	Additional parameters can be added to the JSON body/Form data:

	- `no_rich_text` - if true, html tags are stripped from all statuses requested from the API
	- `hide_followers` - if true, user's followers will be hidden
	- `hide_follows` - if true, user's follows will be hidden
	- `hide_followers_count` - if true, user's follower count will be hidden
	- `hide_follows_count` - if true, user's follow count will be hidden
	- `hide_favorites` - if true, user's favorites timeline will be hidden
	- `show_role` - if true, user's role (e.g admin, moderator) will be exposed to anyone in the API
	- `default_scope` - the scope returned under `privacy` key in Source subentity
	- `pleroma_settings_store` - Opaque user settings to be saved on the backend.
	- `skip_thread_containment` - if true, skip filtering out broken threads
	- `allow_following_move` - if true, allows automatically follow moved following accounts
	- `also_known_as` - array of ActivityPub IDs, needed for following move
	- `pleroma_background_image` - sets the background image of the user. Can be set to "" (an empty string) to reset.
	- `discoverable` - if true, external services (search bots) etc. are allowed to index / list the account (regardless of this setting, user will still appear in regular search results).
	- `actor_type` - the type of this account.
	- `accepts_chat_messages` - if false, this account will reject all chat messages.
	- `language` - user's preferred language for receiving emails (digest, confirmation, etc.)
	- `avatar_description` - image description for user avatar
	- `header_description` - image description for user banner

	All images (avatar, banner and background) can be reset to the default by sending an empty string ("") instead of a file.

	### Pleroma Settings Store

	Pleroma has mechanism that allows frontends to save blobs of json for each user on the backend. This can be used to save frontend-specific settings for a user that the backend does not need to know about.

	The parameter should have a form of `{frontend_name: {...}}`, with `frontend_name` identifying your type of client, e.g. `pleroma_fe`. It will overwrite everything under this property, but will not overwrite other frontend's settings.

	This information is returned in the `/api/v1/accounts/verify_credentials` endpoint.

	## Authentication

	Pleroma supports refreshing tokens.

	### POST `/oauth/token`

	You can obtain access tokens for a user in a few additional ways.

	#### Refreshing a token

	To obtain a new access token from a refresh token, pass `grant_type=refresh_token` with the following extra parameters:

	- `refresh_token`: The refresh token.

	#### Getting a token with a password

	To obtain a token from a user's password, pass `grant_type=password` with the following extra parameters:

	- `username`: Username to authenticate.
	- `password`: The user's password.

	#### Response body

	Additional fields are returned in the response:

	- `id`: The primary key of this token in Pleroma's database.
	- `me` (user tokens only): The ActivityPub ID of the user who owns the token.

	## Account Registration

	`POST /api/v1/accounts`

	Has these additional parameters (which are the same as in Pleroma-API):

	- `fullname`: optional
	- `bio`: optional
	- `captcha_solution`: optional, contains provider-specific captcha solution,
	- `captcha_token`: optional, contains provider-specific captcha token
	- `captcha_answer_data`: optional, contains provider-specific captcha data
	- `token`: invite token required when the registrations aren't public.
	- `language`: optional, user's preferred language for receiving emails (digest, confirmation, etc.), default to the language set in the `userLanguage` cookies or `Accept-Language` header.

	## Instance

	`GET /api/v1/instance` has additional fields

	- `max_toot_chars`: The maximum characters per post
	- `max_media_attachments`: Maximum number of post media attachments
	- `chat_limit`: The maximum characters per chat message
	- `description_limit`: The maximum characters per image description
	- `poll_limits`: The limits of polls
	- `shout_limit`: The maximum characters per Shoutbox message
	- `upload_limit`: The maximum upload file size
	- `avatar_upload_limit`: The same for avatars
	- `background_upload_limit`: The same for backgrounds
	- `banner_upload_limit`: The same for banners
	- `background_image`: A background image that frontends can use
	- `pleroma.metadata.account_activation_required`: Whether users are required to confirm their emails before signing in
	- `pleroma.metadata.birthday_required`: Whether users are required to provide their birth day when signing in
	- `pleroma.metadata.birthday_min_age`: The minimum user age (in days)
	- `pleroma.metadata.features`: A list of supported features
	- `pleroma.metadata.federation`: The federation restrictions of this instance
	- `pleroma.metadata.fields_limits`: A list of values detailing the length and count limitation for various instance-configurable fields.
	- `pleroma.metadata.post_formats`: A list of the allowed post format types
	- `pleroma.stats.mau`: Monthly active user count
	- `pleroma.vapid_public_key`: The public key needed for push messages

	In, `GET /api/v2/instance` Pleroma-specific fields are all moved into `pleroma` object. `max_toot_chars`, `poll_limits` and `upload_limit` are replaced with their MastoAPI counterparts.

	## Push Subscription

	`POST /api/v1/push/subscription`
	`PUT /api/v1/push/subscription`

	Permits these additional alert types:

	- pleroma:chat_mention
	- pleroma:emoji_reaction

	## Markers

	Has these additional fields under the `pleroma` object:

	- `unread_count`: contains number unread notifications

	## Streaming

	### Chats

	There is an additional `user:pleroma_chat` stream. Incoming chat messages will make the current chat be sent to this `user` stream. The `event` of an incoming chat message is `pleroma:chat_update`. The payload is the updated chat with the incoming chat message in the `last_message` field.

	### Remote timelines

	For viewing remote server timelines, there are `public:remote` and `public:remote:media` streams. Each of these accept a parameter like `?instance=lain.com`.

	### Follow relationships updates

	Pleroma streams follow relationships updates as `pleroma:follow_relationships_update` events to the `user` stream.

	The message payload consist of:

	- `state`: a relationship state, one of `follow_pending`, `follow_accept` or `follow_reject`.

	- `follower` and `following` maps with following fields:
	- `id`: user ID
	- `follower_count`: follower count
	- `following_count`: following count

	### Authenticating via `sec-websocket-protocol` header

	Pleroma allows to authenticate via the `sec-websocket-protocol` header, for example, if your access token is `your-access-token`, you can authenticate using the following:

	```
	sec-websocket-protocol: your-access-token
	```

	### Authenticating after connection via `pleroma:authenticate` event

	Pleroma allows to authenticate after connection is established, via the `pleroma:authenticate` event. For example, if your access token is `your-access-token`, you can send the following after the connection is established:

	```
	{"type": "pleroma:authenticate", "token": "your-access-token"}
	```

	### Response to client-sent events

	Pleroma will respond to client-sent events that it recognizes. Supported event types are:

	- `subscribe`
	- `unsubscribe`
	- `pleroma:authenticate`

	The reply will be in the following format:

	```
	{
	"event": "pleroma:respond",
	"payload": "{\"type\": \"<type of the client-sent event>\", \"result\": \"<result of the action>\", \"error\": \"<error code>\"}"
	}
	```

	Result of the action can be either `success`, `ignored` or `error`. If it is `error`, the `error` property will contain the error code. Otherwise, the `error` property will not be present. Below are some examples:

	```
	{
	"event": "pleroma:respond",
	"payload": "{\"type\": \"pleroma:authenticate\", \"result\": \"success\"}"
	}

	{
	"event": "pleroma:respond",
	"payload": "{\"type\": \"subscribe\", \"result\": \"ignored\"}"
	}

	{
	"event": "pleroma:respond",
	"payload": "{\"type\": \"unsubscribe\", \"result\": \"error\", \"error\": \"bad_topic\"}"
	}
	```

	If the sent event is not of a type that Pleroma supports, it will not reply.

	### The `stream` attribute of a server-sent event

	Technically, this is in Mastodon, but its documentation does nothing to specify its format.

	This attribute appears on every event type except `pleroma:respond` and `delete`. It helps clients determine where they should display the new statuses.

	The value of the attribute is an array containing one or two elements. The first element is the type of the stream. The second is the identifier related to that specific stream, if applicable.

	For the following stream types, there is a second element in the array:

	- `list`: The second element is the id of the list, as a string.
	- `hashtag`: The second element is the name of the hashtag.
	- `public:remote:media` and `public:remote`: The second element is the domain of the corresponding instance.

	For all other stream types, there is no second element.

	Some examples of valid `stream` values:

	- `["list", "1"]`: List of id 1.
	- `["hashtag", "mew"]`: The hashtag #mew.
	- `["user:notifications"]`: Notifications for the current user.
	- `["user"]`: Home timeline.
	- `["public:remote", "mew.moe"]`: Public posts from the instance mew.moe .

	### The unified streaming endpoint

	If you do not specify a stream to connect to when requesting `/api/v1/streaming`, you will enter a connection that subscribes to no streams. After the connection is established, you can authenticate and then subscribe to different streams.

	### List of supported streams

	Below is a list of supported streams by Pleroma. To make a single-stream WebSocket connection, append the string specified in "Query style" to the streaming endpoint url.
	To subscribe to a stream after the connection is established, merge the JSON object specified in "Subscribe style" with `{"type": "subscribe"}`. To unsubscribe, merge it with `{"type": "unsubscribe"}`.

	For example, to receive updates on the list 1, you can connect to `/api/v1/streaming/?stream=list&list=1`, or send

	```
	{"type": "subscribe", "stream": "list", "list": "1"}
	```

	upon establishing the websocket connection.

	To unsubscribe to list 1, send

	```
	{"type": "unsubscribe", "stream": "list", "list": "1"}
	```

	Note that if you specify a stream that requires a logged-in user in the query string (for example, `user` or `list`), you have to specify the access token when you are trying to establish the connection, i.e. in the query string or via the `sec-websocket-protocol` header.

	- `list`
	- Query style: `?stream=list&list=<id>`
	- Subscribe style: `{"stream": "list", "list": "<id>"}`
	- `public`, `public:local`, `public:media`, `public:local:media`, `user`, `user:pleroma_chat`, `user:notifications`, `direct`
	- Query style: `?stream=<stream name>`
	- Subscribe style: `{"stream": "<stream name>"}`
	- `hashtag`
	- Query style: `?stream=hashtag&tag=<name>`
	- Subscribe style: `{"stream": "hashtag", "tag": "<name>"}`
	- `public:remote`, `public:remote:media`
	- Query style: `?stream=<stream name>&instance=<instance domain>`
	- Subscribe style: `{"stream": "<stream name>", "instance": "<instance domain>"}`

	## User muting and thread muting

	Both user muting and thread muting can be done for only a certain time by adding an `expires_in` parameter to the API calls and giving the expiration time in seconds.

	## Not implemented

	Pleroma is generally compatible with the Mastodon 2.7.2 API, but some newer features and non-essential features are omitted. These features usually return an HTTP 200 status code, but with an empty response. While they may be added in the future, they are considered low priority.

	### Suggestions

	Added in Mastodon 2.4.3

	- `GET /api/v1/suggestions`: Returns an empty array, `[]`

	### Trends

	Added in Mastodon 3.0.0

	- `GET /api/v1/trends`: Returns an empty array, `[]`

	### Featured tags

	Added in Mastodon 3.0.0

	- `GET /api/v1/featured_tags`: Returns HTTP 404
	diff --git a/docs/installation/optional/media_graphics_packages.md b/docs/installation/optional/media_graphics_packages.md
	index ad01d47d1..89125d1c6 100644
	--- a/docs/installation/optional/media_graphics_packages.md
	+++ b/docs/installation/optional/media_graphics_packages.md
	@@ -1,37 +1,37 @@
	# Optional software packages needed for specific functionality

	For specific Pleroma functionality (which is disabled by default) some or all of the below packages are required:

	* `ImageMagic`
	* `ffmpeg`
	* `exiftool`

	Please refer to documentation in `docs/installation` on how to install them on specific OS.

	Note: the packages are not required with the current default settings of Pleroma.

	## `ImageMagick`

	`ImageMagick` is a set of tools to create, edit, compose, or convert bitmap images.

	It is required for the following Pleroma features:

	-* `Pleroma.Upload.Filters.Mogrify`, `Pleroma.Upload.Filters.Mogrifun` upload filters (related config: `Plaroma.Upload/filters` in `config/config.exs`)
	+* `Pleroma.Upload.Filters.Mogrify`, `Pleroma.Upload.Filters.Mogrifun` upload filters (related config: `Pleroma.Upload/filters` in `config/config.exs`)
	* Media preview proxy for still images (related config: `media_preview_proxy/enabled` in `config/config.exs`)

	## `ffmpeg`

	`ffmpeg` is software to record, convert and stream audio and video.

	It is required for the following Pleroma features:

	* Media preview proxy for videos (related config: `media_preview_proxy/enabled` in `config/config.exs`)

	## `exiftool`

	`exiftool` is media files metadata reader/writer.

	It is required for the following Pleroma features:

	-* `Pleroma.Upload.Filters.Exiftool.StripLocation` upload filter (related config: `Plaroma.Upload/filters` in `config/config.exs`)
	-* `Pleroma.Upload.Filters.Exiftool.ReadDescription` upload filter (related config: `Plaroma.Upload/filters` in `config/config.exs`)
	+* `Pleroma.Upload.Filters.Exiftool.StripLocation` upload filter (related config: `Pleroma.Upload/filters` in `config/config.exs`)
	+* `Pleroma.Upload.Filters.Exiftool.ReadDescription` upload filter (related config: `Pleroma.Upload/filters` in `config/config.exs`)
	diff --git a/lib/pleroma/language/translation/mozhi.ex b/lib/pleroma/language/translation/mozhi.ex
	new file mode 100644
	index 000000000..958f2ef57
	--- /dev/null
	+++ b/lib/pleroma/language/translation/mozhi.ex
	@@ -0,0 +1,109 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2024 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Language.Translation.Mozhi do
	+ import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]
	+
	+ alias Pleroma.Language.Translation.Provider
	+
	+ use Provider
	+
	+ @behaviour Provider
	+
	+ @name "Mozhi"
	+
	+ @impl Provider
	+ def configured?, do: not_empty_string(base_url()) and not_empty_string(engine())
	+
	+ @impl Provider
	+ def translate(content, source_language, target_language) do
	+ endpoint =
	+ base_url()
	+ \|> URI.merge("/api/translate")
	+ \|> URI.to_string()
	+
	+ case Pleroma.HTTP.get(
	+ endpoint <>
	+ "?" <>
	+ URI.encode_query(%{
	+ engine: engine(),
	+ text: content,
	+ from: source_language,
	+ to: target_language
	+ }),
	+ [{"Accept", "application/json"}]
	+ ) do
	+ {:ok, %{status: 200} = res} ->
	+ %{
	+ "translated-text" => content,
	+ "source_language" => source_language
	+ } = Jason.decode!(res.body)
	+
	+ {:ok,
	+ %{
	+ content: content,
	+ detected_source_language: source_language,
	+ provider: @name
	+ }}
	+
	+ _ ->
	+ {:error, :internal_server_error}
	+ end
	+ end
	+
	+ @impl Provider
	+ def supported_languages(type) when type in [:source, :target] do
	+ path =
	+ case type do
	+ :source -> "/api/source_languages"
	+ :target -> "/api/target_languages"
	+ end
	+
	+ endpoint =
	+ base_url()
	+ \|> URI.merge(path)
	+ \|> URI.to_string()
	+
	+ case Pleroma.HTTP.get(
	+ endpoint <>
	+ "?" <>
	+ URI.encode_query(%{
	+ engine: engine()
	+ }),
	+ [{"Accept", "application/json"}]
	+ ) do
	+ {:ok, %{status: 200} = res} ->
	+ languages =
	+ Jason.decode!(res.body)
	+ \|> Enum.map(fn %{"Id" => language} -> language end)
	+
	+ {:ok, languages}
	+
	+ _ ->
	+ {:error, :internal_server_error}
	+ end
	+ end
	+
	+ @impl Provider
	+ def languages_matrix do
	+ with {:ok, source_languages} <- supported_languages(:source),
	+ {:ok, target_languages} <- supported_languages(:target) do
	+ {:ok,
	+ Map.new(source_languages, fn language -> {language, target_languages -- [language]} end)}
	+ else
	+ {:error, error} -> {:error, error}
	+ end
	+ end
	+
	+ @impl Provider
	+ def name, do: @name
	+
	+ defp base_url do
	+ Pleroma.Config.get([__MODULE__, :base_url])
	+ end
	+
	+ defp engine do
	+ Pleroma.Config.get([__MODULE__, :engine])
	+ end
	+end
	diff --git a/lib/pleroma/notification.ex b/lib/pleroma/notification.ex
	index 80844ed71..000bc0dc7 100644
	--- a/lib/pleroma/notification.ex
	+++ b/lib/pleroma/notification.ex
	@@ -1,769 +1,767 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Notification do
	use Ecto.Schema

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.FollowingRelationship
	alias Pleroma.Marker
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	import Ecto.Query
	import Ecto.Changeset

	require Logger

	@type t :: %__MODULE__{}

	@include_muted_option :with_muted

	schema "notifications" do
	field(:seen, :boolean, default: false)
	# This is an enum type in the database. If you add a new notification type,
	# remember to add a migration to add it to the `notifications_type` enum
	# as well.
	field(:type, :string)
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	belongs_to(:activity, Activity, type: FlakeId.Ecto.CompatType)

	timestamps()
	end

	def update_notification_type(user, activity) do
	with %__MODULE__{} = notification <-
	Repo.get_by(__MODULE__, user_id: user.id, activity_id: activity.id) do
	type =
	activity
	\|> type_from_activity()

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

	@spec unread_notifications_count(User.t()) :: integer()
	def unread_notifications_count(%User{id: user_id}) do
	from(q in __MODULE__,
	where: q.user_id == ^user_id and q.seen == false
	)
	\|> Repo.aggregate(:count, :id)
	end

	@notification_types ~w{
	favourite
	follow
	follow_request
	mention
	move
	pleroma:chat_mention
	pleroma:emoji_reaction
	pleroma:report
	reblog
	poll
	status
	update
	}

	def changeset(%Notification{} = notification, attrs) do
	notification
	\|> cast(attrs, [:seen, :type])
	\|> validate_inclusion(:type, @notification_types)
	end

	@spec last_read_query(User.t()) :: Ecto.Queryable.t()
	def last_read_query(user) do
	from(q in Pleroma.Notification,
	where: q.user_id == ^user.id,
	where: q.seen == true,
	select: type(q.id, :string),
	limit: 1,
	order_by: fragment("? desc nulls last", q.id)
	)
	end

	defp for_user_query_ap_id_opts(user, opts) do
	ap_id_relationships =
	[:block] ++
	if opts[@include_muted_option], do: [], else: [:notification_mute]

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(user, ap_id_relationships)

	exclude_blocked_opts = Map.merge(%{blocked_users_ap_ids: preloaded_ap_ids[:block]}, opts)

	exclude_notification_muted_opts =
	Map.merge(%{notification_muted_users_ap_ids: preloaded_ap_ids[:notification_mute]}, opts)

	{exclude_blocked_opts, exclude_notification_muted_opts}
	end

	def for_user_query(user, opts \\ %{}) do
	{exclude_blocked_opts, exclude_notification_muted_opts} =
	for_user_query_ap_id_opts(user, opts)

	Notification
	\|> where(user_id: ^user.id)
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> join(:left, [n, a], object in Object,
	on:
	fragment(
	"(?->>'id') = associated_object_id(?)",
	object.data,
	a.data
	)
	)
	\|> join(:inner, [_n, a], u in User, on: u.ap_id == a.actor, as: :user_actor)
	\|> preload([n, a, o], activity: {a, object: o})
	\|> where([user_actor: user_actor], user_actor.is_active)
	\|> exclude_notification_muted(user, exclude_notification_muted_opts)
	\|> exclude_blocked(user, exclude_blocked_opts)
	\|> exclude_blockers(user)
	\|> exclude_filtered(user)
	\|> exclude_visibility(opts)
	end

	# Excludes blocked users and non-followed domain-blocked users
	defp exclude_blocked(query, user, opts) do
	blocked_ap_ids = opts[:blocked_users_ap_ids] \|\| User.blocked_users_ap_ids(user)

	query
	\|> where([..., user_actor: user_actor], user_actor.ap_id not in ^blocked_ap_ids)
	\|> FollowingRelationship.keep_following_or_not_domain_blocked(user)
	end

	defp exclude_blockers(query, user) do
	if Pleroma.Config.get([:activitypub, :blockers_visible]) == true do
	query
	else
	blocker_ap_ids = User.incoming_relationships_ungrouped_ap_ids(user, [:block])

	query
	\|> where([..., user_actor: user_actor], user_actor.ap_id not in ^blocker_ap_ids)
	end
	end

	defp exclude_notification_muted(query, _, %{@include_muted_option => true}) do
	query
	end

	defp exclude_notification_muted(query, user, opts) do
	notification_muted_ap_ids =
	opts[:notification_muted_users_ap_ids] \|\| User.notification_muted_users_ap_ids(user)

	query
	\|> where([..., user_actor: user_actor], user_actor.ap_id not in ^notification_muted_ap_ids)
	\|> join(:left, [n, a], tm in ThreadMute,
	on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data),
	as: :thread_mute
	)
	\|> where([thread_mute: thread_mute], is_nil(thread_mute.user_id))
	end

	defp exclude_filtered(query, user) do
	case Pleroma.Filter.compose_regex(user) do
	nil ->
	query

	regex ->
	from([_n, a, o] in query,
	where:
	fragment("not(?->>'content' ~* ?)", o.data, ^regex) or
	fragment("?->>'content' is null", o.data) or
	fragment("?->>'actor' = ?", o.data, ^user.ap_id)
	)
	end
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	query
	\|> join(:left, [n, a], mutated_activity in Pleroma.Activity,
	on:
	fragment(
	"associated_object_id(?)",
	a.data
	) ==
	fragment(
	"associated_object_id(?)",
	mutated_activity.data
	) and
	fragment("(?->>'type' = 'Like' or ?->>'type' = 'Announce')", a.data, a.data) and
	fragment("?->>'type'", mutated_activity.data) == "Create",
	as: :mutated_activity
	)
	\|> where(
	[n, a, mutated_activity: mutated_activity],
	not fragment(
	"""
	CASE WHEN (?->>'type') = 'Like' or (?->>'type') = 'Announce'
	THEN (activity_visibility(?, ?, ?) = ANY (?))
	ELSE (activity_visibility(?, ?, ?) = ANY (?)) END
	""",
	a.data,
	a.data,
	mutated_activity.actor,
	mutated_activity.recipients,
	mutated_activity.data,
	^visibility,
	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
	exclude_visibility(query, [visibility])
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end

	defp exclude_visibility(query, _visibility), do: query

	def for_user(user, opts \\ %{}) do
	user
	\|> for_user_query(opts)
	\|> Pagination.fetch_paginated(opts)
	end

	@doc """
	Returns notifications for user received since given date.

	## Examples

	iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-13 11:22:33])
	[%Pleroma.Notification{}, %Pleroma.Notification{}]

	iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-15 11:22:33])
	[]
	"""
	@spec for_user_since(Pleroma.User.t(), NaiveDateTime.t()) :: [t()]
	def for_user_since(user, date) do
	from(n in for_user_query(user),
	where: n.updated_at > ^date
	)
	\|> Repo.all()
	end

	def set_read_up_to(%{id: user_id} = user, id) do
	query =
	from(
	n in Notification,
	where: n.user_id == ^user_id,
	where: n.id <= ^id,
	where: n.seen == false,
	# Ideally we would preload object and activities here
	# but Ecto does not support preloads in update_all
	select: n.id
	)

	Multi.new()
	\|> Multi.update_all(:ids, query, set: [seen: true, updated_at: NaiveDateTime.utc_now()])
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()
	end

	@spec read_one(User.t(), String.t()) ::
	{:ok, Notification.t()} \| {:error, Ecto.Changeset.t()} \| nil
	def read_one(%User{} = user, notification_id) do
	with {:ok, %Notification{} = notification} <- get(user, notification_id) do
	Multi.new()
	\|> Multi.update(:update, changeset(notification, %{seen: true}))
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()
	end
	end

	def get(%{id: user_id} = _user, id) do
	query =
	from(
	n in Notification,
	where: n.id == ^id,
	join: activity in assoc(n, :activity),
	preload: [activity: activity]
	)

	notification = Repo.one(query)

	case notification do
	%{user_id: ^user_id} ->
	{:ok, notification}

	_ ->
	{:error, "Cannot get notification"}
	end
	end

	def clear(user) do
	from(n in Notification, where: n.user_id == ^user.id)
	\|> Repo.delete_all()
	end

	def destroy_multiple(%{id: user_id} = _user, ids) do
	from(n in Notification,
	where: n.id in ^ids,
	where: n.user_id == ^user_id
	)
	\|> Repo.delete_all()
	end

	def dismiss(%Pleroma.Activity{} = activity) do
	Notification
	\|> where([n], n.activity_id == ^activity.id)
	\|> Repo.delete_all()
	\|> case do
	{_, notifications} -> {:ok, notifications}
	_ -> {:error, "Cannot dismiss notification"}
	end
	end

	def dismiss(%{id: user_id} = _user, id) do
	notification = Repo.get(Notification, id)

	case notification do
	%{user_id: ^user_id} ->
	Repo.delete(notification)

	_ ->
	{:error, "Cannot dismiss notification"}
	end
	end

	@spec create_notifications(Activity.t()) :: {:ok, [Notification.t()] \| []}
	def create_notifications(activity)

	def create_notifications(%Activity{data: %{"to" => _, "type" => "Create"}} = activity) do
	object = Object.normalize(activity, fetch: false)

	if object && object.data["type"] == "Answer" do
	{:ok, []}
	else
	do_create_notifications(activity)
	end
	end

	def create_notifications(%Activity{data: %{"type" => type}} = activity)
	when type in ["Follow", "Like", "Announce", "Move", "EmojiReact", "Flag", "Update"] do
	do_create_notifications(activity)
	end

	def create_notifications(_), do: {:ok, []}

	defp do_create_notifications(%Activity{} = activity) do
	enabled_receivers = get_notified_from_activity(activity)

	enabled_subscribers = get_notified_subscribers_from_activity(activity)

	notifications =
	(Enum.map(enabled_receivers, fn user ->
	create_notification(activity, user)
	end) ++
	Enum.map(enabled_subscribers -- enabled_receivers, fn user ->
	create_notification(activity, user, type: "status")
	end))
	\|> Enum.reject(&is_nil/1)

	{:ok, notifications}
	end

	defp type_from_activity(%{data: %{"type" => type}} = activity) do
	case type do
	"Follow" ->
	if Activity.follow_accepted?(activity) do
	"follow"
	else
	"follow_request"
	end

	"Announce" ->
	"reblog"

	"Like" ->
	"favourite"

	"Move" ->
	"move"

	"EmojiReact" ->
	"pleroma:emoji_reaction"

	"Flag" ->
	"pleroma:report"

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

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

	"Update" ->
	"update"

	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

	# TODO move to sql, too.
	def create_notification(%Activity{} = activity, %User{} = user, opts \\ []) do
	type = Keyword.get(opts, :type, type_from_activity(activity))

	unless skip?(activity, user, opts) do
	{:ok, %{notification: notification}} =
	Multi.new()
	\|> Multi.insert(:notification, %Notification{
	user_id: user.id,
	activity: activity,
	seen: mark_as_read?(activity, user),
	type: type
	})
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()

	notification
	end
	end

	def create_poll_notifications(%Activity{} = activity) do
	with %Object{data: %{"type" => "Question", "actor" => actor} = data} <-
	Object.normalize(activity) do
	voters =
	case data do
	%{"voters" => voters} when is_list(voters) -> voters
	_ -> []
	end

	notifications =
	Enum.reduce([actor \| voters], [], fn ap_id, acc ->
	with %User{local: true} = user <- User.get_by_ap_id(ap_id) do
	[create_notification(activity, user, type: "poll") \| acc]
	else
	_ -> acc
	end
	end)

	{:ok, notifications}
	end
	end

	@doc """
	Returns a tuple with 2 elements:
	{notification-enabled receivers, currently disabled receivers (blocking / [thread] muting)}

	NOTE: might be called for FAKE Activities, see ActivityPub.Utils.get_notified_from_object/1
	"""
	@spec get_notified_from_activity(Activity.t(), boolean()) :: list(User.t())
	def get_notified_from_activity(activity, local_only \\ true)

	def get_notified_from_activity(%Activity{data: %{"type" => type}} = activity, local_only)
	when type in [
	"Create",
	"Like",
	"Announce",
	"Follow",
	"Move",
	"EmojiReact",
	"Flag",
	"Update"
	] do
	potential_receiver_ap_ids = get_potential_receiver_ap_ids(activity)

	potential_receivers =
	User.get_users_from_set(potential_receiver_ap_ids, local_only: local_only)

	notification_enabled_ap_ids =
	potential_receiver_ap_ids
	\|> exclude_domain_blocker_ap_ids(activity, potential_receivers)
	\|> exclude_relationship_restricted_ap_ids(activity)
	\|> exclude_thread_muter_ap_ids(activity)

	Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
	end

	def get_notified_from_activity(_, _local_only), do: []

	def get_notified_subscribers_from_activity(activity, local_only \\ true)

	def get_notified_subscribers_from_activity(
	%Activity{data: %{"type" => "Create"}} = activity,
	local_only
	) do
	- notification_enabled_ap_ids =
	- []
	- \|> Utils.maybe_notify_subscribers(activity)
	+ notification_enabled_ap_ids = Utils.get_notified_subscribers(activity)

	potential_receivers =
	User.get_users_from_set(notification_enabled_ap_ids, local_only: local_only)

	Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
	end

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

	# For some activities, only notify the author of the object
	def get_potential_receiver_ap_ids(%{data: %{"type" => type, "object" => object_id}})
	when type in ~w{Like Announce EmojiReact} do
	case Object.get_cached_by_ap_id(object_id) do
	%Object{data: %{"actor" => actor}} ->
	[actor]

	_ ->
	[]
	end
	end

	def get_potential_receiver_ap_ids(%{data: %{"type" => "Follow", "object" => object_id}}) do
	[object_id]
	end

	def get_potential_receiver_ap_ids(%{data: %{"type" => "Flag", "actor" => actor}}) do
	(User.all_users_with_privilege(:reports_manage_reports)
	\|> Enum.map(fn user -> user.ap_id end)) --
	[actor]
	end

	# Update activity: notify all who repeated this
	def get_potential_receiver_ap_ids(%{data: %{"type" => "Update", "actor" => actor}} = activity) do
	with %Object{data: %{"id" => object_id}} <- Object.normalize(activity, fetch: false) do
	repeaters =
	Activity.Queries.by_type("Announce")
	\|> Activity.Queries.by_object_id(object_id)
	\|> Activity.with_joined_user_actor()
	\|> where([a, u], u.local)
	\|> select([a, u], u.ap_id)
	\|> Repo.all()

	repeaters -- [actor]
	end
	end

	def get_potential_receiver_ap_ids(activity) do
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	\|> Utils.maybe_notify_followers(activity)
	\|> Enum.uniq()
	end

	@doc "Filters out AP IDs domain-blocking and not following the activity's actor"
	def exclude_domain_blocker_ap_ids(ap_ids, activity, preloaded_users \\ [])

	def exclude_domain_blocker_ap_ids([], _activity, _preloaded_users), do: []

	def exclude_domain_blocker_ap_ids(ap_ids, %Activity{} = activity, preloaded_users) do
	activity_actor_domain = activity.actor && URI.parse(activity.actor).host

	users =
	ap_ids
	\|> Enum.map(fn ap_id ->
	Enum.find(preloaded_users, &(&1.ap_id == ap_id)) \|\|
	User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)

	domain_blocker_ap_ids = for u <- users, activity_actor_domain in u.domain_blocks, do: u.ap_id

	domain_blocker_follower_ap_ids =
	if Enum.any?(domain_blocker_ap_ids) do
	activity
	\|> Activity.user_actor()
	\|> FollowingRelationship.followers_ap_ids(domain_blocker_ap_ids)
	else
	[]
	end

	ap_ids
	\|> Kernel.--(domain_blocker_ap_ids)
	\|> Kernel.++(domain_blocker_follower_ap_ids)
	end

	@doc "Filters out AP IDs of users basing on their relationships with activity actor user"
	def exclude_relationship_restricted_ap_ids([], _activity), do: []

	def exclude_relationship_restricted_ap_ids(ap_ids, %Activity{} = activity) do
	relationship_restricted_ap_ids =
	activity
	\|> Activity.user_actor()
	\|> User.incoming_relationships_ungrouped_ap_ids([
	:block,
	:notification_mute
	])

	Enum.uniq(ap_ids) -- relationship_restricted_ap_ids
	end

	@doc "Filters out AP IDs of users who mute activity thread"
	def exclude_thread_muter_ap_ids([], _activity), do: []

	def exclude_thread_muter_ap_ids(ap_ids, %Activity{} = activity) do
	thread_muter_ap_ids = ThreadMute.muter_ap_ids(activity.data["context"])

	Enum.uniq(ap_ids) -- thread_muter_ap_ids
	end

	def skip?(activity, user, opts \\ [])

	@spec skip?(Activity.t(), User.t(), Keyword.t()) :: boolean()
	def skip?(%Activity{} = activity, %User{} = user, opts) do
	[
	:self,
	:internal,
	:invisible,
	:block_from_strangers,
	:recently_followed,
	:filtered
	]
	\|> Enum.find(&skip?(&1, activity, user, opts))
	end

	def skip?(_activity, _user, _opts), do: false

	@spec skip?(atom(), Activity.t(), User.t(), Keyword.t()) :: boolean()
	def skip?(:self, %Activity{} = activity, %User{} = user, opts) do
	cond do
	opts[:type] == "poll" -> false
	activity.data["actor"] == user.ap_id -> true
	true -> false
	end
	end

	def skip?(:internal, %Activity{} = activity, _user, _opts) do
	actor = activity.data["actor"]
	user = User.get_cached_by_ap_id(actor)
	User.internal?(user)
	end

	def skip?(:invisible, %Activity{} = activity, _user, _opts) do
	actor = activity.data["actor"]
	user = User.get_cached_by_ap_id(actor)
	User.invisible?(user)
	end

	def skip?(
	:block_from_strangers,
	%Activity{} = activity,
	%User{notification_settings: %{block_from_strangers: true}} = user,
	opts
	) do
	actor = activity.data["actor"]
	follower = User.get_cached_by_ap_id(actor)

	cond do
	opts[:type] == "poll" -> false
	user.ap_id == actor -> false
	!User.following?(user, follower) -> true
	true -> false
	end
	end

	# To do: consider defining recency in hours and checking FollowingRelationship with a single SQL
	def skip?(
	:recently_followed,
	%Activity{data: %{"type" => "Follow"}} = activity,
	%User{} = user,
	_opts
	) do
	actor = activity.data["actor"]

	Notification.for_user(user)
	\|> Enum.any?(fn
	%{activity: %{data: %{"type" => "Follow", "actor" => ^actor}}} -> true
	_ -> false
	end)
	end

	def skip?(:filtered, %{data: %{"type" => type}}, _user, _opts) when type in ["Follow", "Move"],
	do: false

	def skip?(:filtered, activity, user, _opts) do
	object = Object.normalize(activity, fetch: false)

	cond do
	is_nil(object) ->
	false

	object.data["actor"] == user.ap_id ->
	false

	not is_nil(regex = Pleroma.Filter.compose_regex(user, :re)) ->
	Regex.match?(regex, object.data["content"])

	true ->
	false
	end
	end

	def skip?(_type, _activity, _user, _opts), do: false

	def mark_as_read?(activity, target_user) do
	user = Activity.user_actor(activity)
	User.mutes_user?(target_user, user) \|\| CommonAPI.thread_muted?(activity, target_user)
	end

	def for_user_and_activity(user, activity) do
	from(n in __MODULE__,
	where: n.user_id == ^user.id,
	where: n.activity_id == ^activity.id
	)
	\|> Repo.one()
	end

	@spec mark_context_as_read(User.t(), String.t()) :: {integer(), nil \| [term()]}
	def mark_context_as_read(%User{id: id}, context) do
	from(
	n in Notification,
	join: a in assoc(n, :activity),
	where: n.user_id == ^id,
	where: n.seen == false,
	where: fragment("?->>'context'", a.data) == ^context
	)
	\|> Repo.update_all(set: [seen: true])
	end

	@doc "Streams a list of notifications over websockets and web push"
	@spec stream(list(Notification.t())) :: :ok
	def stream(notifications) do
	Enum.each(notifications, fn notification ->
	Streamer.stream(["user", "user:notification"], notification)
	Push.send(notification)
	end)
	end
	end
	diff --git a/lib/pleroma/signature.ex b/lib/pleroma/signature.ex
	index 47d9d46f6..fca61799b 100644
	--- a/lib/pleroma/signature.ex
	+++ b/lib/pleroma/signature.ex
	@@ -1,141 +1,141 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Signature do
	@behaviour Pleroma.Signature.API
	@behaviour HTTPSignatures.Adapter

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Keys
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub

	import Plug.Conn, only: [put_req_header: 3]

	@http_signatures_impl Application.compile_env(
	:pleroma,
	[__MODULE__, :http_signatures_impl],
	HTTPSignatures
	)

	@known_suffixes ["/publickey", "/main-key"]

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

	maybe_ap_id = URI.to_string(uri)

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

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

	defp remove_suffix(uri, [test \| rest]) do
	if not is_nil(uri.path) and String.ends_with?(uri.path, test) do
	Map.put(uri, :path, String.replace(uri.path, test, ""))
	else
	remove_suffix(uri, rest)
	end
	end

	defp remove_suffix(uri, []), do: uri

	def fetch_public_key(conn) do
	with {:ok, actor_id} <- get_actor_id(conn),
	- {:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
	+ {:ok, public_key} <- User.get_or_fetch_public_key_for_ap_id(actor_id) do
	{:ok, public_key}
	else
	e ->
	{:error, e}
	end
	end

	def refetch_public_key(conn) do
	with {:ok, actor_id} <- get_actor_id(conn),
	{: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 get_actor_id(conn) do
	with %{"keyId" => kid} <- HTTPSignatures.signature_for_conn(conn),
	{:ok, actor_id} <- key_id_to_actor_id(kid) do
	{:ok, actor_id}
	else
	e ->
	{:error, e}
	end
	end

	def sign(%User{keys: keys} = user, headers) do
	with {: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

	@spec validate_signature(Plug.Conn.t(), String.t()) :: boolean()
	def validate_signature(%Plug.Conn{} = conn, request_target) do
	# Newer drafts for HTTP signatures now use @request-target instead of the
	# old (request-target). We'll now support both for incoming signatures.
	conn =
	conn
	\|> put_req_header("(request-target)", request_target)
	\|> put_req_header("@request-target", request_target)

	@http_signatures_impl.validate_conn(conn)
	end

	@spec validate_signature(Plug.Conn.t()) :: boolean()
	def validate_signature(%Plug.Conn{} = conn) do
	# This (request-target) is non-standard, but many implementations do it
	# this way due to a misinterpretation of
	# https://datatracker.ietf.org/doc/html/draft-cavage-http-signatures-06
	# "path" was interpreted as not having the query, though later examples
	# show that it must be the absolute path + query. This behavior is kept to
	# make sure most software (Pleroma itself, Mastodon, and probably others)
	# do not break.
	request_target = Enum.join([String.downcase(conn.method), conn.request_path], " ")

	# This is the proper way to build the @request-target, as expected by
	# many HTTP signature libraries, clarified in the following draft:
	# https://www.ietf.org/archive/id/draft-ietf-httpbis-message-signatures-11.html#section-2.2.6
	# It is the same as before, but containing the query part as well.
	proper_target = Enum.join([request_target, "?", conn.query_string], "")

	cond do
	# Normal, non-standard behavior but expected by Pleroma and more.
	validate_signature(conn, request_target) ->
	true

	# Has query string and the previous one failed: let's try the standard.
	conn.query_string != "" ->
	validate_signature(conn, proper_target)

	# If there's no query string and signature fails, it's rotten.
	true ->
	false
	end
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 468e124b5..f8e32af8a 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2938 +1,2947 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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]
	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

	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.Hashtag
	alias Pleroma.HTML
	alias Pleroma.Keys
	alias Pleroma.MFA
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.User.HashtagFollow
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.RelMe
	alias Pleroma.Workers.BackgroundWorker
	alias Pleroma.Workers.DeleteWorker
	alias Pleroma.Workers.UserRefreshWorker

	require Logger
	require Pleroma.Constants

	@type t :: %__MODULE__{}
	@type account_status ::
	:active
	\| :deactivated
	\| :password_reset_pending
	\| :confirmation_pending
	\| :approval_pending
	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/

	@strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
	@extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/

	# AP ID user relationships (blocks, mutes etc.)
	# Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
	@user_relationships_config [
	block: [
	blocker_blocks: :blocked_users,
	blockee_blocks: :blocker_users
	],
	mute: [
	muter_mutes: :muted_users,
	mutee_mutes: :muter_users
	],
	reblog_mute: [
	reblog_muter_mutes: :reblog_muted_users,
	reblog_mutee_mutes: :reblog_muter_users
	],
	notification_mute: [
	notification_muter_mutes: :notification_muted_users,
	notification_mutee_mutes: :notification_muter_users
	],
	# Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
	inverse_subscription: [
	subscribee_subscriptions: :subscriber_users,
	subscriber_subscriptions: :subscribee_users
	],
	endorsement: [
	endorser_endorsements: :endorsed_users,
	endorsee_endorsements: :endorser_users
	]
	]

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)

	schema "users" do
	field(:bio, :string, default: "")
	field(:raw_bio, :string)
	field(:email, :string)
	field(:name, :string)
	field(:nickname, :string)
	field(:password_hash, :string)
	field(:password, :string, virtual: true)
	field(:password_confirmation, :string, virtual: true)
	field(:keys, :string)
	field(:public_key, :string)
	field(:ap_id, :string)
	field(:avatar, :map, default: %{})
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:featured_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(:is_locked, :boolean, default: false)
	field(:is_confirmed, :boolean, default: true)
	field(:password_reset_pending, :boolean, default: false)
	field(:is_approved, :boolean, default: true)
	field(:registration_reason, :string, default: nil)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:domain_blocks, {:array, :string}, default: [])
	field(:is_active, :boolean, default: true)
	field(:no_rich_text, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	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(: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(:is_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, ObjectValidators.BareUri}, default: [])
	field(:inbox, :string)
	field(:shared_inbox, :string)
	field(:accepts_chat_messages, :boolean, default: nil)
	field(:last_active_at, :naive_datetime)
	field(:disclose_client, :boolean, default: true)
	field(:pinned_objects, :map, default: %{})
	field(:is_suggested, :boolean, default: false)
	field(:last_status_at, :naive_datetime)
	field(:birthday, :date)
	field(:show_birthday, :boolean, default: false)
	field(:language, :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)

	many_to_many(:followed_hashtags, Hashtag,
	on_replace: :delete,
	on_delete: :delete_all,
	join_through: HashtagFollow
	)

	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, :endorser_endorsements
	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, :endorsee_endorsements
	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, :endorsed_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, :endorser_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 endorsed_users_relation/2`
	+ # `def reblog_muted_users_relation/2`, `def notification_muted_users_relation/2`,
	+ # `def subscriber_users_relation/2`, `def endorsed_users_relation/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
	target_users_query
	\|> User.Query.build(%{deactivated: false})
	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 endorsed_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 endorsed_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

	def cached_blocked_users_ap_ids(user) do
	@cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
	blocked_users_ap_ids(user)
	end)
	end

	def cached_muted_users_ap_ids(user) do
	@cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
	muted_users_ap_ids(user)
	end)
	end

	defdelegate following_count(user), to: FollowingRelationship
	defdelegate following(user), to: FollowingRelationship
	defdelegate following?(follower, followed), to: FollowingRelationship
	defdelegate following_ap_ids(user), to: FollowingRelationship
	defdelegate get_follow_requests(user), to: FollowingRelationship
	defdelegate search(query, opts \\ []), to: User.Search

	@doc """
	Dumps Flake Id to SQL-compatible format (16-byte UUID).
	E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
	"""
	def binary_id(source_id) when is_binary(source_id) do
	with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
	dumped_id
	else
	_ -> source_id
	end
	end

	def binary_id(source_ids) when is_list(source_ids) do
	Enum.map(source_ids, &binary_id/1)
	end

	def binary_id(%User{} = user), do: binary_id(user.id)

	@doc "Returns account status"
	@spec account_status(User.t()) :: account_status()
	def account_status(%User{is_active: false}), do: :deactivated
	def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
	def account_status(%User{local: true, is_approved: false}), do: :approval_pending
	def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
	def account_status(%User{}), do: :active

	@spec visible_for(User.t(), User.t() \| nil) ::
	:visible
	\| :invisible
	\| :restricted_unauthenticated
	\| :deactivated
	\| :confirmation_pending
	def visible_for(user, for_user \\ nil)

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

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

	def visible_for(%User{} = user, nil) do
	if restrict_unauthenticated?(user) do
	:restrict_unauthenticated
	else
	visible_account_status(user)
	end
	end

	def visible_for(%User{} = user, for_user) do
	if privileged?(for_user, :users_manage_activation_state) do
	:visible
	else
	visible_account_status(user)
	end
	end

	def visible_for(_, _), do: :invisible

	defp restrict_unauthenticated?(%User{local: true}) do
	Config.restrict_unauthenticated_access?(:profiles, :local)
	end

	defp restrict_unauthenticated?(%User{local: _}) do
	Config.restrict_unauthenticated_access?(:profiles, :remote)
	end

	defp visible_account_status(user) do
	status = account_status(user)

	if status in [:active, :password_reset_pending] do
	:visible
	else
	status
	end
	end

	@spec privileged?(User.t(), atom()) :: boolean()
	def privileged?(%User{is_admin: false, is_moderator: false}, _), do: false

	def privileged?(
	%User{local: true, is_admin: is_admin, is_moderator: is_moderator},
	privilege_tag
	),
	do:
	privileged_for?(privilege_tag, is_admin, :admin_privileges) or
	privileged_for?(privilege_tag, is_moderator, :moderator_privileges)

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

	defp privileged_for?(privilege_tag, true, config_role_key),
	do: privilege_tag in Config.get([:instance, config_role_key])

	defp privileged_for?(_, _, _), do: false

	@spec privileges(User.t()) :: [atom()]
	def privileges(%User{local: false}) do
	[]
	end

	def privileges(%User{is_moderator: false, is_admin: false}) do
	[]
	end

	def privileges(%User{local: true, is_moderator: true, is_admin: true}) do
	(Config.get([:instance, :moderator_privileges]) ++ Config.get([:instance, :admin_privileges]))
	\|> Enum.uniq()
	end

	def privileges(%User{local: true, is_moderator: true, is_admin: false}) do
	Config.get([:instance, :moderator_privileges])
	end

	def privileges(%User{local: true, is_moderator: false, is_admin: true}) do
	Config.get([:instance, :admin_privileges])
	end

	@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], "#{Endpoint.url()}/images/avi.png")
	end
	end
	end

	def banner_url(user, options \\ []) do
	case user.banner do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> !options[:no_default] && "#{Endpoint.url()}/images/banner.png"
	end
	end

	def image_description(image, default \\ "")

	def image_description(%{"name" => name}, _default), do: name
	def image_description(_, default), do: default

	# Should probably be renamed or removed
	@spec ap_id(User.t()) :: String.t()
	def ap_id(%User{nickname: nickname}), do: "#{Endpoint.url()}/users/#{nickname}"

	@spec ap_followers(User.t()) :: String.t()
	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 ap_featured_collection(User.t()) :: String.t()
	def ap_featured_collection(%User{featured_address: fa}) when is_binary(fa), do: fa

	def ap_featured_collection(%User{} = user), do: "#{ap_id(user)}/collections/featured"

	defp truncate_fields_param(params) do
	if Map.has_key?(params, :fields) do
	Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
	else
	params
	end
	end

	defp truncate_if_exists(params, key, max_length) do
	if Map.has_key?(params, key) and is_binary(params[key]) do
	{value, _chopped} = String.split_at(params[key], max_length)
	Map.put(params, key, value)
	else
	params
	end
	end

	defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params

	defp fix_follower_address(%{nickname: nickname} = params),
	do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))

	defp fix_follower_address(params), do: params

	def remote_user_changeset(struct \\ %User{local: false}, params) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)
	fields_limit = Config.get([:instance, :max_remote_account_fields], 0)

	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)
	\|> Map.update(:fields, [], &Enum.take(&1, fields_limit))
	\|> truncate_fields_param()
	\|> fix_follower_address()

	struct
	\|> cast(
	params,
	[
	:bio,
	:emoji,
	:ap_id,
	:inbox,
	:shared_inbox,
	:nickname,
	:public_key,
	:avatar,
	:banner,
	:is_locked,
	:last_refreshed_at,
	:uri,
	:follower_address,
	:following_address,
	:featured_address,
	:hide_followers,
	:hide_follows,
	:hide_followers_count,
	:hide_follows_count,
	:follower_count,
	:fields,
	:following_count,
	:is_discoverable,
	:invisible,
	:actor_type,
	:also_known_as,
	:accepts_chat_messages,
	:pinned_objects,
	:birthday,
	:show_birthday
	]
	)
	\|> cast(params, [:name], empty_values: [])
	\|> validate_required([:ap_id])
	\|> validate_required([:name], trim: false)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> validate_fields(true)
	\|> validate_non_local()
	end

	defp validate_non_local(cng) do
	local? = get_field(cng, :local)

	if local? do
	cng
	\|> add_error(:local, "User is local, can't update with this changeset.")
	else
	cng
	end
	end

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

	struct
	\|> cast(
	params,
	[
	:bio,
	:raw_bio,
	:name,
	:emoji,
	:avatar,
	:public_key,
	:inbox,
	:shared_inbox,
	:is_locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:hide_followers_count,
	:hide_follows_count,
	:hide_favorites,
	:allow_following_move,
	:also_known_as,
	:background,
	:show_role,
	:skip_thread_containment,
	:fields,
	:raw_fields,
	:pleroma_settings_store,
	:is_discoverable,
	:actor_type,
	:accepts_chat_messages,
	:disclose_client,
	:birthday,
	:show_birthday
	]
	)
	\|> validate_min_age()
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_inclusion(:actor_type, Pleroma.Constants.allowed_user_actor_types())
	\|> validate_image_description(:avatar_description, params)
	\|> validate_image_description(:header_description, params)
	\|> put_fields()
	\|> put_emoji()
	\|> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
	\|> put_change_if_present(
	:avatar,
	&put_upload(&1, :avatar, Map.get(params, :avatar_description))
	)
	\|> put_change_if_present(
	:banner,
	&put_upload(&1, :banner, Map.get(params, :header_description))
	)
	\|> put_change_if_present(:background, &put_upload(&1, :background))
	\|> put_change_if_present(
	:pleroma_settings_store,
	&{:ok, Map.merge(struct.pleroma_settings_store, &1)}
	)
	\|> maybe_update_image_description(:avatar, Map.get(params, :avatar_description))
	\|> maybe_update_image_description(:banner, Map.get(params, :header_description))
	\|> validate_fields(false)
	end

	defp put_fields(changeset) do
	if raw_fields = get_change(changeset, :raw_fields) do
	old_fields = changeset.data.raw_fields

	raw_fields =
	raw_fields
	\|> Enum.filter(fn %{"name" => n} -> n != "" end)
	\|> Enum.map(fn field ->
	previous =
	old_fields
	\|> Enum.find(fn %{"value" => value} -> field["value"] == value end)

	if previous && Map.has_key?(previous, "verified_at") do
	field
	\|> Map.put("verified_at", previous["verified_at"])
	else
	field
	end
	end)

	fields =
	raw_fields
	\|> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)

	changeset
	\|> put_change(:raw_fields, raw_fields)
	\|> put_change(:fields, fields)
	else
	changeset
	end
	end

	defp parse_fields(value) do
	value
	\|> Formatter.linkify(mentions_format: :full)
	\|> elem(0)
	end

	defp put_emoji(changeset) do
	emojified_fields = [:bio, :name, :raw_fields]

	if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
	bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
	name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))

	emoji = Map.merge(bio, name)

	emoji =
	changeset
	\|> get_field(:raw_fields)
	\|> Enum.reduce(emoji, fn x, acc ->
	Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
	end)

	put_change(changeset, :emoji, emoji)
	else
	changeset
	end
	end

	defp put_change_if_present(changeset, map_field, value_function) do
	with {:ok, value} <- fetch_change(changeset, map_field),
	{:ok, new_value} <- value_function.(value) do
	put_change(changeset, map_field, new_value)
	else
	{:error, :file_too_large} ->
	Ecto.Changeset.validate_change(changeset, map_field, fn map_field, _value ->
	[{map_field, "file is too large"}]
	end)

	_ ->
	changeset
	end
	end

	defp put_upload(value, type, description \\ nil) do
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: type, description: description) do
	{:ok, object.data}
	end
	end

	defp validate_image_description(changeset, key, params) do
	description_limit = Config.get([:instance, :description_limit], 5_000)
	description = Map.get(params, key)

	if is_binary(description) and String.length(description) > description_limit do
	changeset
	\|> add_error(key, "#{key} is too long")
	else
	changeset
	end
	end

	defp maybe_update_image_description(changeset, image_field, description)
	when is_binary(description) do
	with {:image_missing, true} <- {:image_missing, not changed?(changeset, image_field)},
	{:existing_image, %{"id" => id}} <-
	{:existing_image, Map.get(changeset.data, image_field)},
	{:object, %Object{} = object} <- {:object, Object.get_by_ap_id(id)},
	{:ok, object} <- Object.update_data(object, %{"name" => description}) do
	put_change(changeset, image_field, object.data)
	else
	{:description_too_long, true} -> {:error}
	_ -> changeset
	end
	end

	defp maybe_update_image_description(changeset, _, _), do: changeset

	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, Ecto.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, Ecto.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.new(%{"op" => "force_password_reset", "user_id" => user.id})
	\|> Oban.insert()
	end

	@spec force_password_reset(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def force_password_reset(user), do: update_password_reset_pending(user, true)

	# Used to auto-register LDAP accounts which won't have a password hash stored locally
	def register_changeset_ldap(struct, params = %{password: password})
	when is_nil(password) do
	params = Map.put_new(params, :accepts_chat_messages, true)

	struct
	\|> cast(params, [
	:name,
	:nickname,
	:email,
	:accepts_chat_messages
	])
	\|> validate_required([:name, :nickname])
	\|> unique_constraint(:nickname)
	\|> validate_not_restricted_nickname(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_and_featured_address()
	\|> put_private_key()
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)
	reason_limit = Config.get([:instance, :registration_reason_length], 500)
	params = Map.put_new(params, :accepts_chat_messages, true)

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

	approved? =
	if is_nil(opts[:approved]) do
	!Config.get([:instance, :account_approval_required])
	else
	opts[:approved]
	end

	struct
	\|> confirmation_changeset(set_confirmation: confirmed?)
	\|> approval_changeset(set_approval: approved?)
	\|> cast(params, [
	:bio,
	:raw_bio,
	:email,
	:name,
	:nickname,
	:password,
	:password_confirmation,
	:emoji,
	:accepts_chat_messages,
	:registration_reason,
	:birthday,
	:language
	])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_email_not_in_blacklisted_domain(:email)
	\|> unique_constraint(:nickname)
	\|> validate_not_restricted_nickname(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_length(:registration_reason, max: reason_limit)
	\|> maybe_validate_required_email(opts[:external])
	\|> maybe_validate_required_birthday
	\|> validate_min_age()
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_and_featured_address()
	\|> put_private_key()
	end

	def validate_not_restricted_nickname(changeset, field) do
	validate_change(changeset, field, fn _, value ->
	valid? =
	Config.get([User, :restricted_nicknames])
	\|> Enum.all?(fn restricted_nickname ->
	String.downcase(value) != String.downcase(restricted_nickname)
	end)

	if valid?, do: [], else: [nickname: "Invalid nickname"]
	end)
	end

	defp validate_email_not_in_blacklisted_domain(changeset, field) do
	validate_change(changeset, field, fn _, value ->
	valid? =
	Config.get([User, :email_blacklist])
	\|> Enum.all?(fn blacklisted_domain ->
	blacklisted_domain_downcase = String.downcase(blacklisted_domain)

	!String.ends_with?(String.downcase(value), [
	"@" <> blacklisted_domain_downcase,
	"." <> blacklisted_domain_downcase
	])
	end)

	if valid?, do: [], else: [email: "Invalid email"]
	end)
	end

	defp maybe_validate_required_email(changeset, true), do: changeset

	defp maybe_validate_required_email(changeset, _) do
	if Config.get([:instance, :account_activation_required]) do
	validate_required(changeset, [:email])
	else
	changeset
	end
	end

	defp maybe_validate_required_birthday(changeset) do
	if Config.get([:instance, :birthday_required]) do
	validate_required(changeset, [:birthday])
	else
	changeset
	end
	end

	defp validate_min_age(changeset) do
	changeset
	\|> validate_change(:birthday, fn :birthday, birthday ->
	valid? =
	Date.utc_today()
	\|> Date.diff(birthday) >=
	Config.get([:instance, :birthday_min_age])

	if valid?, do: [], else: [birthday: "Invalid age"]
	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_and_featured_address(changeset) do
	user = %User{nickname: get_field(changeset, :nickname)}
	followers = ap_followers(user)
	following = ap_following(user)
	featured = ap_featured_collection(user)

	changeset
	\|> put_change(:follower_address, followers)
	\|> put_change(:following_address, following)
	\|> put_change(:featured_address, featured)
	end

	defp put_private_key(changeset) do
	{:ok, pem} = Keys.generate_rsa_pem()
	put_change(changeset, :keys, pem)
	end

	defp autofollow_users(user) do
	candidates = Config.get([:instance, :autofollowed_nicknames])

	autofollowed_users =
	User.Query.build(%{nickname: candidates, local: true, is_active: true})
	\|> Repo.all()

	follow_all(user, autofollowed_users)
	end

	defp autofollowing_users(user) do
	candidates = Config.get([:instance, :autofollowing_nicknames])

	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()
	\|> Enum.each(&follow(&1, user, :follow_accept))

	{:ok, :success}
	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{is_confirmed: false} = user) do
	with {:ok, _} <- maybe_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{is_approved: false} = user) do
	with {:ok, _} <- send_user_approval_email(user),
	{:ok, _} <- send_admin_approval_emails(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
	with {:ok, user} <- autofollow_users(user),
	{:ok, _} <- autofollowing_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- maybe_send_registration_email(user),
	{:ok, _} <- maybe_send_welcome_email(user),
	{:ok, _} <- maybe_send_welcome_message(user),
	{:ok, _} <- maybe_send_welcome_chat_message(user) do
	{:ok, user}
	end
	end

	defp send_user_approval_email(%User{email: email} = user) when is_binary(email) do
	user
	\|> Pleroma.Emails.UserEmail.approval_pending_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	end

	defp send_user_approval_email(_user) do
	{:ok, :skipped}
	end

	defp send_admin_approval_emails(user) do
	all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, :enqueued}
	end

	defp maybe_send_welcome_message(user) do
	if User.WelcomeMessage.enabled?() do
	User.WelcomeMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_chat_message(user) do
	if User.WelcomeChatMessage.enabled?() do
	User.WelcomeChatMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
	if User.WelcomeEmail.enabled?() do
	User.WelcomeEmail.send_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_email(_), do: {:ok, :noop}

	@spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued \| :noop}
	def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
	when is_binary(email) do
	if Config.get([:instance, :account_activation_required]) do
	send_confirmation_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def maybe_send_confirmation_email(_), do: {:ok, :noop}

	@spec send_confirmation_email(User.t()) :: User.t()
	def send_confirmation_email(%User{} = user) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	user
	end

	@spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued \| :noop}
	defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
	with false <- User.WelcomeEmail.enabled?(),
	false <- Config.get([:instance, :account_activation_required], false),
	false <- Config.get([:instance, :account_approval_required], false) do
	user
	\|> Pleroma.Emails.UserEmail.successful_registration_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	else
	_ ->
	{:ok, :noop}
	end
	end

	defp maybe_send_registration_email(_), do: {:ok, :noop}

	defp needs_update?(%User{local: true}), do: false

	defp needs_update?(%User{local: false, last_refreshed_at: nil}), do: true

	defp needs_update?(%User{local: false} = user) do
	NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
	end

	defp needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) ::
	{:ok, User.t(), User.t()} \| {:error, String.t()}

	# "Locked" (self-locked) users demand explicit authorization of follow requests
	def maybe_direct_follow(%User{} = follower, %User{local: true, is_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
	{:ok, follower, followed}
	end

	@doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
	@spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
	def follow_all(follower, followeds) do
	followeds
	\|> Enum.reject(fn followed -> blocks?(follower, followed) \|\| blocks?(followed, follower) end)
	\|> Enum.each(&follow(follower, &1, :follow_accept))

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	cond do
	not followed.is_active ->
	{: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)
	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)

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

	@doc "Returns follow state as Pleroma.FollowingRelationship.State value"
	def get_follow_state(%User{} = follower, %User{} = following) do
	following_relationship = FollowingRelationship.get(follower, following)
	get_follow_state(follower, following, following_relationship)
	end

	def get_follow_state(
	%User{} = follower,
	%User{} = following,
	following_relationship
	) do
	case {following_relationship, following.local} do
	{nil, false} ->
	case Utils.fetch_latest_follow(follower, following) do
	%Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
	FollowingRelationship.state_to_enum(state)

	_ ->
	nil
	end

	{%{state: state}, _} ->
	state

	{nil, _} ->
	nil
	end
	end

	def locked?(%User{} = user) do
	user.is_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_by_uri(uri) do
	Repo.get_by(User, uri: uri)
	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
	if get_change(changeset, :raw_fields) do
	BackgroundWorker.new(%{"op" => "verify_fields_links", "user_id" => user.id})
	\|> Oban.insert()
	end

	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}")
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	@cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
	end

	@spec get_cached_by_ap_id(String.t()) :: User.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"

	with {:ok, nil} <- @cachex.get(:user_cache, key),
	user when not is_nil(user) <- get_by_ap_id(ap_id),
	{:ok, true} <- @cachex.put(:user_cache, key, user) do
	user
	else
	{:ok, user} -> user
	nil -> nil
	end
	end

	def get_cached_by_id(id) do
	key = "id:#{id}"

	ap_id =
	@cachex.fetch!(:user_cache, key, fn _ ->
	user = get_by_id(id)

	if user do
	@cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	{:commit, user.ap_id}
	else
	{:ignore, ""}
	end
	end)

	get_cached_by_ap_id(ap_id)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"

	@cachex.fetch!(:user_cache, key, fn _ ->
	case get_or_fetch_by_nickname(nickname) do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
	restrict_to_local = Config.get([:instance, :limit_to_local_content])

	cond do
	is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)

	restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
	get_cached_by_nickname(nickname_or_id)

	restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
	get_cached_by_nickname(nickname_or_id)

	true ->
	nil
	end
	end

	@spec get_by_nickname(String.t()) :: User.t() \| nil
	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname) \|\|
	- if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
	+ 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, is_active: true})
	end

	def get_followers_query(%User{} = user, page) do
	user
	\|> get_followers_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_followers_query(User.t()) :: Ecto.Query.t()
	def get_followers_query(%User{} = user), do: get_followers_query(user, nil)

	@spec get_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> Repo.all()
	end

	@spec get_external_followers(User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_external_followers(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> User.Query.build(%{external: true})
	\|> Repo.all()
	end

	def get_followers_ids(%User{} = user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	@spec get_friends_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_friends_query(%User{} = user, nil) do
	User.Query.build(%{friends: user, deactivated: false})
	end

	def get_friends_query(%User{} = user, page) do
	user
	\|> get_friends_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_friends_query(User.t()) :: Ecto.Query.t()
	def get_friends_query(%User{} = user), do: get_friends_query(user, nil)

	def get_friends(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

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

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

	@spec get_familiar_followers_query(User.t(), User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_familiar_followers_query(%User{} = user, %User{} = current_user, nil) do
	friends =
	get_friends_query(current_user)
	\|> where([u], not u.hide_follows)
	\|> select([u], u.id)

	User.Query.build(%{is_active: true})
	\|> where([u], u.id not in ^[user.id, current_user.id])
	\|> join(:inner, [u], r in FollowingRelationship,
	as: :followers_relationships,
	on: r.following_id == ^user.id and r.follower_id == u.id
	)
	\|> where([followers_relationships: r], r.state == ^:follow_accept)
	\|> where([followers_relationships: r], r.follower_id in subquery(friends))
	end

	def get_familiar_followers_query(%User{} = user, %User{} = current_user, page) do
	user
	\|> get_familiar_followers_query(current_user, nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_familiar_followers_query(User.t(), User.t()) :: Ecto.Query.t()
	def get_familiar_followers_query(%User{} = user, %User{} = current_user),
	do: get_familiar_followers_query(user, current_user, nil)

	@spec get_familiar_followers(User.t(), User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_familiar_followers(%User{} = user, %User{} = current_user, page \\ nil) do
	user
	\|> get_familiar_followers_query(current_user, page)
	\|> Repo.all()
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], inc: [note_count: 1])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def decrease_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	note_count: fragment("greatest(0, note_count - 1)")
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def update_note_count(%User{} = user, note_count \\ nil) do
	note_count =
	note_count \|\|
	from(
	a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)
	)
	\|> Repo.one()

	user
	\|> cast(%{note_count: note_count}, [:note_count])
	\|> update_and_set_cache()
	end

	@spec maybe_fetch_follow_information(User.t()) :: User.t()
	def maybe_fetch_follow_information(user) do
	with {:ok, user} <- fetch_follow_information(user) do
	user
	else
	e ->
	Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	user
	\|> follow_information_changeset(info)
	\|> update_and_set_cache()
	end
	end

	defp follow_information_changeset(user, params) do
	user
	\|> cast(params, [
	:hide_followers,
	:hide_follows,
	:follower_count,
	:following_count,
	:hide_followers_count,
	:hide_follows_count
	])
	end

	@spec update_follower_count(User.t()) :: {:ok, User.t()}
	def update_follower_count(%User{} = user) do
	if user.local or !Config.get([:instance, :external_user_synchronization]) do
	follower_count = FollowingRelationship.follower_count(user)

	user
	\|> follow_information_changeset(%{follower_count: follower_count})
	\|> update_and_set_cache
	else
	{:ok, maybe_fetch_follow_information(user)}
	end
	end

	@spec update_following_count(User.t()) :: {:ok, User.t()}
	def update_following_count(%User{local: false} = user) do
	if Config.get([:instance, :external_user_synchronization]) do
	{:ok, maybe_fetch_follow_information(user)}
	else
	{:ok, user}
	end
	end

	def update_following_count(%User{local: true} = user) do
	following_count = FollowingRelationship.following_count(user)

	user
	\|> follow_information_changeset(%{following_count: following_count})
	\|> update_and_set_cache()
	end

	@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, is_active: true}
	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, is_active: true})

	query
	\|> Repo.all()
	end

	@spec mute(User.t(), User.t(), map()) ::
	{:ok, list(UserRelationship.t())} \| {:error, String.t()}
	def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
	notifications? = Map.get(params, :notifications, true)
	duration = Map.get(params, :duration, 0)

	expires_at =
	if duration > 0 do
	DateTime.utc_now()
	\|> DateTime.add(duration)
	else
	nil
	end

	with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee, expires_at),
	{:ok, user_notification_mute} <-
	(notifications? &&
	UserRelationship.create_notification_mute(
	muter,
	mutee,
	expires_at
	)) \|\|
	{:ok, nil} do
	if duration > 0 do
	Pleroma.Workers.MuteExpireWorker.new(
	%{"op" => "unmute_user", "muter_id" => muter.id, "mutee_id" => mutee.id},
	scheduled_at: expires_at
	)
	\|> Oban.insert()
	end

	@cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")

	{:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
	end
	end

	def unmute(%User{} = muter, %User{} = mutee) do
	with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
	{:ok, user_notification_mute} <-
	UserRelationship.delete_notification_mute(muter, mutee) do
	@cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
	{:ok, [user_mute, user_notification_mute]}
	end
	end

	def unmute(muter_id, mutee_id) do
	with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
	{:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
	unmute(muter, mutee)
	else
	{who, result} = error ->
	Logger.warning(
	"User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
	)

	{:error, error}
	end
	end

	def subscribe(%User{} = subscriber, %User{} = target) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	if blocks?(target, subscriber) and deny_follow_blocked do
	{:error, "Could not subscribe: #{target.nickname} is blocking you"}
	else
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.create_inverse_subscription(target, subscriber)
	end
	end

	def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
	with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
	subscribe(subscriber, subscribee)
	end
	end

	def unsubscribe(%User{} = unsubscriber, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.delete_inverse_subscription(target, unsubscriber)
	end

	def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unsubscribe(unsubscriber, user)
	end
	end

	def block(blocker, blocked, params \\ %{})

	def block(%User{} = blocker, %User{} = blocked, params) 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 from both sides as well
	blocked =
	case CommonAPI.reject_follow_request(blocked, blocker) do
	{:ok, %User{} = updated_blocked} -> updated_blocked
	nil -> blocked
	end

	blocker =
	case CommonAPI.reject_follow_request(blocker, blocked) do
	{:ok, %User{} = updated_blocker} -> updated_blocker
	nil -> blocker
	end

	unsubscribe(blocked, blocker)

	unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
	if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)

	{:ok, blocker} = update_follower_count(blocker)
	{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)

	duration = Map.get(params, :duration, 0)

	expires_at =
	if duration > 0 do
	DateTime.utc_now()
	\|> DateTime.add(duration)
	else
	nil
	end

	user_block = add_to_block(blocker, blocked, expires_at)

	if duration > 0 do
	Pleroma.Workers.MuteExpireWorker.new(
	%{"op" => "unblock_user", "blocker_id" => blocker.id, "blocked_id" => blocked.id},
	scheduled_at: expires_at
	)
	\|> Oban.insert()
	end

	user_block
	end

	# helper to handle the block given only an actor's AP id
	def block(%User{} = blocker, %{ap_id: ap_id}, params) do
	block(blocker, get_cached_by_ap_id(ap_id), params)
	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 endorse(%User{} = endorser, %User{} = target) do
	with max_endorsed_users <- Pleroma.Config.get([:instance, :max_endorsed_users], 0),
	endorsed_users <-
	User.endorsed_users_relation(endorser)
	\|> Repo.aggregate(:count, :id) do
	cond do
	endorsed_users >= max_endorsed_users ->
	{:error, "You have already pinned the maximum number of users"}

	not following?(endorser, target) ->
	{:error, "Could not endorse: You are not following #{target.nickname}"}

	true ->
	UserRelationship.create_endorsement(endorser, target)
	end
	end
	end

	def endorse(%User{} = endorser, %{ap_id: ap_id}) do
	with %User{} = endorsed <- get_cached_by_ap_id(ap_id) do
	endorse(endorser, endorsed)
	end
	end

	def unendorse(%User{} = unendorser, %User{} = target) do
	UserRelationship.delete_endorsement(unendorser, target)
	end

	def unendorse(%User{} = unendorser, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unendorse(unendorser, user)
	end
	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

	def endorses?(%User{} = user, %User{} = target) do
	UserRelationship.endorsement_exists?(user, target)
	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 set_activation_async(user, status \\ true) do
	BackgroundWorker.new(%{"op" => "user_activation", "user_id" => user.id, "status" => status})
	\|> Oban.insert()
	end

	@spec set_activation([User.t()], boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_activation(users, status) when is_list(users) do
	Repo.transaction(fn ->
	for user <- users do
	{:ok, user} = set_activation(user, status)
	user
	end
	end)
	end

	@spec set_activation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_activation(%User{} = user, status) do
	with {:ok, user} <- set_activation_status(user, status) do
	user
	\|> get_followers()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&set_cache(update_following_count(&1)))

	# Only update local user counts, remote will be update during the next pull.
	user
	\|> get_friends()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&do_unfollow(user, &1))

	{:ok, user}
	end
	end

	def approve(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- approve(user), do: user
	end)
	end)
	end

	def approve(%User{is_approved: false} = user) do
	with chg <- change(user, is_approved: true),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def approve(%User{} = user), do: {:ok, user}

	def confirm(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- confirm(user), do: user
	end)
	end)
	end

	def confirm(%User{is_confirmed: false} = user) do
	with chg <- confirmation_changeset(user, set_confirmation: true),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def confirm(%User{} = user), do: {:ok, user}

	def set_suggestion(users, is_suggested) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- set_suggestion(user, is_suggested), do: user
	end)
	end)
	end

	def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}

	def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
	user
	\|> change(is_suggested: is_suggested)
	\|> update_and_set_cache()
	end

	def update_notification_settings(%User{} = user, settings) do
	user
	\|> cast(%{notification_settings: settings}, [])
	\|> cast_embed(:notification_settings)
	\|> validate_required([:notification_settings])
	\|> update_and_set_cache()
	end

	@spec purge_user_changeset(User.t()) :: Ecto.Changeset.t()
	defp purge_user_changeset(user) do
	# "Right to be forgotten"
	# https://gdpr.eu/right-to-be-forgotten/
	change(user, %{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	avatar: %{},
	tags: [],
	last_refreshed_at: nil,
	last_digest_emailed_at: nil,
	banner: %{},
	background: %{},
	note_count: 0,
	follower_count: 0,
	following_count: 0,
	is_locked: false,
	password_reset_pending: false,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	is_active: false,
	is_moderator: false,
	is_admin: false,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	# id: preserved
	# ap_id: preserved
	# nickname: preserved
	})
	end

	# Purge doesn't delete the user from the database.
	# It just nulls all its fields and deactivates it.
	# See `User.purge_user_changeset/1` above.
	defp purge(%User{} = user) do
	user
	\|> purge_user_changeset()
	\|> 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
	# Purge the user immediately
	purge(user)

	DeleteWorker.new(%{"op" => "delete_user", "user_id" => user.id})
	\|> Oban.insert()
	end

	# Actually delete the user from the DB
	defp delete_from_db(%User{} = user) do
	invalidate_cache(user)
	Repo.delete(user)
	end

	# If the user never finalized their account, it's safe to delete them.
	defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
	do: delete_from_db(user)

	defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
	do: delete_from_db(user)

	defp maybe_delete_from_db(user), do: {:ok, user}

	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
	# Purge the user again, in case perform/2 is called directly
	purge(user)

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

	maybe_delete_from_db(user)
	end

	def perform(:verify_fields_links, user) do
	profile_urls = [user.ap_id]

	fields =
	user.raw_fields
	\|> Enum.map(&verify_field_link(&1, profile_urls))

	changeset =
	user
	\|> update_changeset(%{raw_fields: fields})

	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	set_cache(user)
	end
	end

	def perform(:set_activation_async, user, status), do: set_activation(user, status)

	defp verify_field_link(field, profile_urls) do
	verified_at =
	with %{"value" => value} <- field,
	{:verified_at, nil} <- {:verified_at, Map.get(field, "verified_at")},
	%{scheme: scheme, userinfo: nil, host: host}
	when not_empty_string(host) and scheme in ["http", "https"] <-
	URI.parse(value),
	{:not_idn, true} <-
	{:not_idn, match?(^host, to_string(:idna.encode(to_charlist(host))))},
	"me" <- Pleroma.Web.RelMe.maybe_put_rel_me(value, profile_urls) do
	CommonUtils.to_masto_date(NaiveDateTime.utc_now())
	else
	{:verified_at, value} when not_empty_string(value) ->
	value

	_ ->
	nil
	end

	Map.put(field, "verified_at", verified_at)
	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

	defp delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
	Notification
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> where([n, a], fragment("? = ?", a.actor, ^ap_id))
	\|> Repo.delete_all()
	end

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.chunk_stream(50, :batches)
	\|> Stream.each(fn activities ->
	Enum.each(activities, fn activity -> delete_activity(activity, user) end)
	end)
	\|> Stream.run()
	end

	defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
	with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
	{:ok, delete_data, _} <- Builder.delete(user, object) do
	Pipeline.common_pipeline(delete_data, local: user.local)
	else
	{:find_object, nil} ->
	# We have the create activity, but not the object, it was probably pruned.
	# Insert a tombstone and try again
	with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	delete_activity(activity, user)
	end

	e ->
	Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
	Logger.error("Error: #{inspect(e)}")
	end
	end

	defp delete_activity(%{data: %{"type" => type}} = activity, user)
	when type in ["Like", "Announce"] do
	{:ok, undo, _} = Builder.undo(user, activity)
	Pipeline.common_pipeline(undo, local: user.local)
	end

	defp delete_activity(_activity, _user), do: "Doing nothing"

	defp delete_outgoing_pending_follow_requests(user) do
	user
	\|> FollowingRelationship.outgoing_pending_follow_requests_query()
	\|> Repo.delete_all()
	end

	def html_filter_policy(%User{no_rich_text: true}) do
	Pleroma.HTML.Scrubber.TwitterText
	end

	def html_filter_policy(_), do: Config.get([:markup, :scrub_policy])

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

	@spec get_or_fetch_by_ap_id(String.t()) :: {:ok, User.t()} \| {:error, any()}
	def get_or_fetch_by_ap_id(ap_id) do
	with cached_user = %User{} <- get_cached_by_ap_id(ap_id),
	_ <- maybe_refresh(cached_user) do
	{:ok, cached_user}
	else
	_ -> fetch_by_ap_id(ap_id)
	end
	end

	defp maybe_refresh(user) do
	if needs_update?(user) do
	UserRefreshWorker.new(%{"ap_id" => user.ap_id})
	\|> Oban.insert()
	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
	\|> put_private_key()
	\|> 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_or_fetch_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 get_public_key_for_ap_id(ap_id) do
	with %User{} = user <- get_cached_by_ap_id(ap_id),
	{:ok, public_key} <- public_key(user) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

	@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("https://" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

	# wait a period of time and return newest version of the User structs
	# this is because we have synchronous follow APIs and need to simulate them
	# with an async handshake
	def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
	with %User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
	with :ok <- :timer.sleep(timeout),
	%User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def parse_bio(bio) when is_binary(bio) and bio != "" do
	bio
	\|> CommonUtils.format_input("text/plain", mentions_format: :full)
	\|> elem(0)
	end

	def parse_bio(_), do: ""

	def parse_bio(bio, user) when is_binary(bio) and bio != "" do
	# TODO: get profile URLs other than user.ap_id
	profile_urls = [user.ap_id]

	bio
	\|> CommonUtils.format_input("text/plain",
	mentions_format: :full,
	rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
	)
	\|> elem(0)
	end

	def parse_bio(_, _), do: ""

	def tag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
	end)
	end

	def tag(nickname, tags) when is_binary(nickname),
	do: tag(get_by_nickname(nickname), tags)

	def tag(%User{} = user, tags),
	do: update_tags(user, Enum.uniq((user.tags \|\| []) ++ normalize_tags(tags)))

	def untag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
	end)
	end

	def untag(nickname, tags) when is_binary(nickname),
	do: untag(get_by_nickname(nickname), tags)

	def untag(%User{} = user, tags),
	do: update_tags(user, (user.tags \|\| []) -- normalize_tags(tags))

	defp update_tags(%User{} = user, new_tags) do
	{:ok, updated_user} =
	user
	\|> change(%{tags: new_tags})
	\|> update_and_set_cache()

	updated_user
	end

	defp normalize_tags(tags) do
	[tags]
	\|> List.flatten()
	\|> Enum.map(&String.downcase/1)
	end

	defp local_nickname_regex do
	if Config.get([:instance, :extended_nickname_format]) do
	@extended_local_nickname_regex
	else
	@strict_local_nickname_regex
	end
	end

	def local_nickname(nickname_or_mention) do
	nickname_or_mention
	\|> full_nickname()
	\|> String.split("@")
	\|> hd()
	end

	def full_nickname(%User{} = user) do
	if String.contains?(user.nickname, "@") do
	user.nickname
	else
	host = Pleroma.Web.WebFinger.host()
	user.nickname <> "@" <> host
	end
	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, is_active: true})
	\|> Repo.all()
	end

	@spec all_users_with_privilege(atom()) :: [User.t()]
	def all_users_with_privilege(privilege) do
	User.Query.build(%{is_privileged: privilege}) \|> 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.is_active == ^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 set_confirmation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_confirmation(%User{} = user, bool) do
	user
	\|> confirmation_changeset(set_confirmation: bool)
	\|> update_and_set_cache()
	end

	def get_mascot(%{mascot: %{} = mascot}) when not is_nil(mascot) do
	mascot
	end

	def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
	# use instance-default
	config = Config.get([:assets, :mascots])
	default_mascot = Config.get([:assets, :default_mascot])
	mascot = Keyword.get(config, default_mascot)

	%{
	"id" => "default-mascot",
	"url" => mascot[:url],
	"preview_url" => mascot[:url],
	"pleroma" => %{
	"mime_type" => mascot[:mime_type]
	}
	}
	end

	def get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	order_by: fragment("array_position(?, ?)", ^nicknames, u.nickname),
	select: u.ap_id
	)
	\|> Repo.all()
	end

	defp put_password_hash(
	%Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
	) do
	change(changeset, password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt(password))
	end

	defp put_password_hash(changeset), do: changeset

	def internal?(%User{nickname: nil}), do: true
	def internal?(%User{local: true, nickname: "internal." <> _}), do: true
	def internal?(_), 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])
	\|> maybe_validate_required_email(false)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> update_and_set_cache()
	end

	def alias_users(user) do
	user.also_known_as
	\|> Enum.map(&User.get_cached_by_ap_id/1)
	\|> Enum.filter(fn user -> user != nil end)
	end

	def add_alias(user, new_alias_user) do
	current_aliases = user.also_known_as \|\| []
	new_alias_ap_id = new_alias_user.ap_id

	if new_alias_ap_id in current_aliases do
	{:ok, user}
	else
	user
	\|> cast(%{also_known_as: current_aliases ++ [new_alias_ap_id]}, [:also_known_as])
	\|> update_and_set_cache()
	end
	end

	def delete_alias(user, alias_user) do
	current_aliases = user.also_known_as \|\| []
	alias_ap_id = alias_user.ap_id

	if alias_ap_id in current_aliases do
	user
	\|> cast(%{also_known_as: current_aliases -- [alias_ap_id]}, [:also_known_as])
	\|> update_and_set_cache()
	else
	{:error, :no_such_alias}
	end
	end

	# Internal function; public one is `set_activation/2`
	defp set_activation_status(user, status) do
	user
	\|> cast(%{is_active: status}, [:is_active])
	\|> 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

	defp validate_fields(changeset, remote?) do
	limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
	limit = Config.get([:instance, limit_name], 0)

	changeset
	\|> validate_length(:fields, max: limit)
	\|> validate_change(:fields, fn :fields, fields ->
	if Enum.all?(fields, &valid_field?/1) do
	[]
	else
	[fields: "invalid"]
	end
	end)
	end

	defp valid_field?(%{"name" => name, "value" => value}) do
	name_limit = Config.get([:instance, :account_field_name_length], 255)
	value_limit = Config.get([:instance, :account_field_value_length], 255)

	is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
	String.length(value) <= value_limit
	end

	defp valid_field?(_), do: false

	defp truncate_field(%{"name" => name, "value" => value}) do
	{name, _chopped} =
	String.split_at(name, Config.get([:instance, :account_field_name_length], 255))

	{value, _chopped} =
	String.split_at(value, Config.get([:instance, :account_field_value_length], 255))

	%{"name" => name, "value" => value}
	end

	def admin_api_update(user, params) do
	user
	\|> cast(params, [
	:is_moderator,
	:is_admin,
	:show_role
	])
	\|> update_and_set_cache()
	end

	@doc "Signs user out of all applications"
	def global_sign_out(user) do
	OAuth.Authorization.delete_user_authorizations(user)
	OAuth.Token.delete_user_tokens(user)
	end

	def mascot_update(user, url) do
	user
	\|> cast(%{mascot: url}, [:mascot])
	\|> validate_required([:mascot])
	\|> update_and_set_cache()
	end

	@spec confirmation_changeset(User.t(), keyword()) :: Ecto.Changeset.t()
	def confirmation_changeset(user, set_confirmation: confirmed?) do
	params =
	if confirmed? do
	%{
	is_confirmed: true,
	confirmation_token: nil
	}
	else
	%{
	is_confirmed: false,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	}
	end

	cast(user, params, [:is_confirmed, :confirmation_token])
	end

	@spec approval_changeset(Ecto.Changeset.t(), keyword()) :: Ecto.Changeset.t()
	def approval_changeset(changeset, set_approval: approved?) do
	cast(changeset, %{is_approved: approved?}, [:is_approved])
	end

	@spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} \| {:error, term()}
	def add_pinned_object_id(%User{} = user, object_id) do
	if !user.pinned_objects[object_id] do
	params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}

	user
	\|> cast(params, [:pinned_objects])
	\|> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
	max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)

	if Enum.count(pinned_objects) <= max_pinned_statuses do
	[]
	else
	[pinned_objects: "You have already pinned the maximum number of statuses"]
	end
	end)
	else
	change(user)
	end
	\|> update_and_set_cache()
	end

	@spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} \| {:error, term()}
	def remove_pinned_object_id(%User{} = user, object_id) do
	user
	\|> cast(
	%{pinned_objects: Map.delete(user.pinned_objects, object_id)},
	[:pinned_objects]
	)
	\|> 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(), integer() \| nil) ::
	{:ok, UserRelationship.t()} \| {:error, Ecto.Changeset.t()}
	defp add_to_block(%User{} = user, %User{} = blocked, expires_at) do
	with {:ok, relationship} <- UserRelationship.create_block(user, blocked, expires_at) do
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	@spec remove_from_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:ok, nil} \| {:error, Ecto.Changeset.t()}
	defp remove_from_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	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} = fields ->
	%{
	"name" => name,
	"value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly),
	"verified_at" => Map.get(fields, "verified_at")
	}
	end)

	user
	\|> Map.put(:bio, HTML.filter_tags(user.bio, filter))
	\|> Map.put(:fields, fields)
	end

	def get_host(%User{ap_id: ap_id} = _user) do
	URI.parse(ap_id).host
	end

	def update_last_active_at(%__MODULE__{local: true} = user) do
	user
	\|> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
	\|> update_and_set_cache()
	end

	def update_last_active_at(user), do: user

	def active_user_count(days \\ 30) do
	active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)

	__MODULE__
	\|> where([u], u.last_active_at >= ^active_after)
	\|> where([u], u.local == true)
	\|> Repo.aggregate(:count)
	end

	def update_last_status_at(user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], set: [last_status_at: fragment("NOW()")])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def get_friends_birthdays_query(%User{} = user, day, month) do
	User.Query.build(%{
	friends: user,
	deactivated: false,
	birthday_day: day,
	birthday_month: month
	})
	end

	defp maybe_load_followed_hashtags(%User{followed_hashtags: follows} = user)
	when is_list(follows),
	do: user

	defp maybe_load_followed_hashtags(%User{} = user) do
	followed_hashtags = HashtagFollow.get_by_user(user)
	%{user \| followed_hashtags: followed_hashtags}
	end

	def followed_hashtags(%User{followed_hashtags: follows})
	when is_list(follows),
	do: follows

	def followed_hashtags(%User{} = user) do
	{:ok, user} =
	user
	\|> maybe_load_followed_hashtags()
	\|> set_cache()

	user.followed_hashtags
	end

	def follow_hashtag(%User{} = user, %Hashtag{} = hashtag) do
	Logger.debug("Follow hashtag #{hashtag.name} for user #{user.nickname}")
	user = maybe_load_followed_hashtags(user)

	with {:ok, _} <- HashtagFollow.new(user, hashtag),
	follows <- HashtagFollow.get_by_user(user),
	%User{} = user <- user \|> Map.put(:followed_hashtags, follows) do
	user
	\|> set_cache()
	end
	end

	def unfollow_hashtag(%User{} = user, %Hashtag{} = hashtag) do
	Logger.debug("Unfollow hashtag #{hashtag.name} for user #{user.nickname}")
	user = maybe_load_followed_hashtags(user)

	with {:ok, _} <- HashtagFollow.delete(user, hashtag),
	follows <- HashtagFollow.get_by_user(user),
	%User{} = user <- user \|> Map.put(:followed_hashtags, follows) do
	user
	\|> set_cache()
	end
	end

	def following_hashtag?(%User{} = user, %Hashtag{} = hashtag) do
	not is_nil(HashtagFollow.get(user, hashtag))
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/publisher.ex b/lib/pleroma/web/activity_pub/publisher.ex
	index b1c8a8fc1..b6c814aed 100644
	--- a/lib/pleroma/web/activity_pub/publisher.ex
	+++ b/lib/pleroma/web/activity_pub/publisher.ex
	@@ -1,406 +1,421 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Publisher do
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Delivery
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Publisher.Prepared
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Workers.PublisherWorker

	require Pleroma.Constants

	import Pleroma.Web.ActivityPub.Visibility

	require Logger

	@moduledoc """
	ActivityPub outgoing federation module.
	"""

	@signature_impl Application.compile_env(
	:pleroma,
	[__MODULE__, :signature_impl],
	Pleroma.Signature
	)

	@transmogrifier_impl Application.compile_env(
	:pleroma,
	[__MODULE__, :transmogrifier_impl],
	Pleroma.Web.ActivityPub.Transmogrifier
	)

	@doc """
	Enqueue publishing a single activity.
	"""
	@spec enqueue_one(map(), Keyword.t()) :: {:ok, %Oban.Job{}}
	def enqueue_one(%{} = params, worker_args \\ []) do
	PublisherWorker.new(
	%{"op" => "publish_one", "params" => params},
	worker_args
	)
	\|> Oban.insert()
	end

	@doc """
	Gathers a set of remote users given an IR envelope.
	"""
	def remote_users(%User{id: user_id}, %{data: %{"to" => to} = data}) do
	cc = Map.get(data, "cc", [])

	bcc =
	data
	\|> Map.get("bcc", [])
	\|> Enum.reduce([], fn ap_id, bcc ->
	case Pleroma.List.get_by_ap_id(ap_id) do
	%Pleroma.List{user_id: ^user_id} = list ->
	{:ok, following} = Pleroma.List.get_following(list)
	bcc ++ Enum.map(following, & &1.ap_id)

	_ ->
	bcc
	end
	end)

	[to, cc, bcc]
	\|> Enum.concat()
	\|> Enum.map(&User.get_cached_by_ap_id/1)
	\|> Enum.filter(fn user -> user && !user.local end)
	end

	@doc """
	Determine if an activity can be represented by running it through Transmogrifier.
	"""
	def representable?(%Activity{} = activity) do
	with {:ok, _data} <- @transmogrifier_impl.prepare_outgoing(activity.data) do
	true
	else
	_e ->
	false
	end
	end

	@doc """
	Prepare an activity for publishing from an Oban job
	* `inbox`: the inbox to publish to
	* `activity_id`: the internal activity id
	* `cc`: the cc recipients relevant to this inbox (optional)
	"""
	@spec prepare_one(map()) :: Prepared.t()
	def prepare_one(%{inbox: inbox, activity_id: activity_id} = params) do
	activity = Activity.get_by_id_with_user_actor(activity_id)
	actor = activity.user_actor

	ap_id = activity.data["id"]
	Logger.debug("Federating #{ap_id} to #{inbox}")
	uri = %{path: path} = URI.parse(inbox)

	{:ok, data} = @transmogrifier_impl.prepare_outgoing(activity.data)

	{actor, data} =
	with {_, false} <- {:actor_changed?, data["actor"] != activity.data["actor"]} do
	{actor, data}
	else
	{:actor_changed?, true} ->
	# If prepare_outgoing changes the actor, re-get it from the db
	new_actor = User.get_cached_by_ap_id(data["actor"])
	{new_actor, data}
	end

	param_cc = Map.get(params, :cc, [])

	original_cc = Map.get(data, "cc", [])

	public_address = Pleroma.Constants.as_public()

	# Ensure unlisted posts don't lose the public address in the cc
	# if the param_cc was set
	cc =
	if public_address in original_cc and public_address not in param_cc do
	[public_address \| param_cc]
	else
	param_cc
	end

	json =
	data
	\|> Map.put("cc", cc)
	\|> Jason.encode!()

	digest = "SHA-256=" <> (:crypto.hash(:sha256, json) \|> Base.encode64())

	date = @signature_impl.signed_date()

	signature =
	@signature_impl.sign(actor, %{
	"(request-target)": "post #{path}",
	host: signature_host(uri),
	"content-length": byte_size(json),
	digest: digest,
	date: date
	})

	%Prepared{
	activity_id: activity_id,
	json: json,
	date: date,
	signature: signature,
	digest: digest,
	inbox: inbox,
	unreachable_since: params[:unreachable_since]
	}
	end

	@doc """
	Publish a single message to a peer. Takes a struct with the following
	parameters set:
	* `activity_id`: the activity id
	* `json`: the json payload
	* `date`: the signed date from Pleroma.Signature.signed_date()
	* `signature`: the signature from Pleroma.Signature.sign/2
	* `digest`: base64 encoded the hash of the json payload prefixed with "SHA-256="
	* `inbox`: the inbox URI of this delivery
	* `unreachable_since`: timestamp the instance was marked unreachable

	"""
	def publish_one(%Prepared{} = p) do
	with {:ok, %{status: code}} = result when code in 200..299 <-
	HTTP.post(
	p.inbox,
	p.json,
	[
	{"Content-Type", "application/activity+json"},
	{"Date", p.date},
	{"signature", p.signature},
	{"digest", p.digest}
	]
	) do
	result
	else
	{_post_result, %{status: code} = response} = e ->
	Logger.metadata(activity: p.activity_id, inbox: p.inbox, status: code)
	Logger.error("Publisher failed to inbox #{p.inbox} with status #{code}")

	case response do
	%{status: 400} -> {:cancel, :bad_request}
	%{status: 403} -> {:cancel, :forbidden}
	%{status: 404} -> {:cancel, :not_found}
	%{status: 410} -> {:cancel, :not_found}
	_ -> {:error, e}
	end

	{:error, {:already_started, _}} ->
	Logger.debug("Publisher snoozing worker job due worker :already_started race condition")
	connection_pool_snooze()

	{:error, :pool_full} ->
	Logger.debug("Publisher snoozing worker job due to full connection pool")
	connection_pool_snooze()

	e ->
	Logger.metadata(activity: p.activity_id, inbox: p.inbox)
	Logger.error("Publisher failed to inbox #{p.inbox} #{inspect(e)}")
	{:error, e}
	end
	end

	defp connection_pool_snooze, do: {:snooze, 3}

	defp signature_host(%URI{port: port, scheme: scheme, host: host}) do
	if port == URI.default_port(scheme) do
	host
	else
	"#{host}:#{port}"
	end
	end

	def should_federate?(nil, _), do: false
	def should_federate?(_, true), do: true

	def should_federate?(inbox, _) do
	%{host: host} = URI.parse(inbox)

	quarantined_instances =
	Config.get([:instance, :quarantined_instances], [])
	\|> Pleroma.Web.ActivityPub.MRF.instance_list_from_tuples()
	\|> Pleroma.Web.ActivityPub.MRF.subdomains_regex()

	!Pleroma.Web.ActivityPub.MRF.subdomain_match?(quarantined_instances, host)
	end

	@spec recipients(User.t(), Activity.t()) :: [[User.t()]]
	defp recipients(actor, activity) do
	followers =
	if actor.follower_address in activity.recipients do
	User.get_external_followers(actor)
	else
	[]
	end

	fetchers =
	with %Activity{data: %{"type" => "Delete"}} <- activity,
	%Object{id: object_id} <- Object.normalize(activity, fetch: false),
	fetchers <- User.get_delivered_users_by_object_id(object_id),
	_ <- Delivery.delete_all_by_object_id(object_id) do
	fetchers
	else
	_ ->
	[]
	end

	mentioned = remote_users(actor, activity)
	non_mentioned = (followers ++ fetchers) -- mentioned

	[mentioned, non_mentioned]
	end

	defp get_cc_ap_ids(ap_id, recipients) do
	host = Map.get(URI.parse(ap_id), :host)

	recipients
	\|> Enum.filter(fn %User{ap_id: ap_id} -> Map.get(URI.parse(ap_id), :host) == host end)
	\|> Enum.map(& &1.ap_id)
	end

	defp maybe_use_sharedinbox(%User{shared_inbox: nil, inbox: inbox}), do: inbox
	defp maybe_use_sharedinbox(%User{shared_inbox: shared_inbox}), do: shared_inbox

	@doc """
	Determine a user inbox to use based on heuristics. These heuristics
	are based on an approximation of the ``sharedInbox`` rules in the
	[ActivityPub specification][ap-sharedinbox].

	Please do not edit this function (or its children) without reading
	the spec, as editing the code is likely to introduce some breakage
	without some familiarity.

	[ap-sharedinbox]: https://www.w3.org/TR/activitypub/#shared-inbox-delivery
	"""
	def determine_inbox(
	%Activity{data: activity_data},
	%User{inbox: inbox} = user
	) do
	to = activity_data["to"] \|\| []
	cc = activity_data["cc"] \|\| []
	type = activity_data["type"]

	cond do
	type == "Delete" ->
	maybe_use_sharedinbox(user)

	Pleroma.Constants.as_public() in to \|\| Pleroma.Constants.as_public() in cc ->
	maybe_use_sharedinbox(user)

	length(to) + length(cc) > 1 ->
	maybe_use_sharedinbox(user)

	true ->
	inbox
	end
	end

	@doc """
	Publishes an activity with BCC to all relevant peers.
	"""

	def publish(%User{} = actor, %{data: %{"bcc" => bcc}} = activity)
	when is_list(bcc) and bcc != [] do
	public = public?(activity)

	[priority_recipients, recipients] = recipients(actor, activity)

	[priority_inboxes, other_inboxes] =
	[priority_recipients, recipients]
	\|> Enum.map(fn recipients ->
	recipients
	\|> Enum.map(fn %User{} = user ->
	determine_inbox(activity, user)
	end)
	\|> Enum.uniq()
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	\|> Instances.filter_reachable()
	end)

	Repo.checkout(fn ->
	Enum.each([priority_inboxes, other_inboxes], fn inboxes ->
	Enum.each(inboxes, fn inbox ->
	- %User{ap_id: ap_id} = Enum.find(recipients, fn actor -> actor.inbox == inbox end)
	+ {%User{ap_id: ap_id}, priority} =
	+ get_user_with_priority(inbox, priority_recipients, recipients)

	# Get all the recipients on the same host and add them to cc. Otherwise, a remote
	# instance would only accept a first message for the first recipient and ignore the rest.
	cc = get_cc_ap_ids(ap_id, recipients)

	- __MODULE__.enqueue_one(%{
	- inbox: inbox,
	- cc: cc,
	- activity_id: activity.id
	- })
	+ __MODULE__.enqueue_one(
	+ %{
	+ inbox: inbox,
	+ cc: cc,
	+ activity_id: activity.id
	+ },
	+ priority: priority
	+ )
	end)
	end)
	end)
	end

	# Publishes an activity to all relevant peers.
	def publish(%User{} = actor, %Activity{} = activity) do
	public = public?(activity)

	if public && Config.get([:instance, :allow_relay]) do
	Logger.debug(fn -> "Relaying #{activity.data["id"]} out" end)
	Relay.publish(activity)
	end

	[priority_inboxes, inboxes] =
	recipients(actor, activity)
	\|> Enum.map(fn recipients ->
	recipients
	\|> Enum.map(fn %User{} = user ->
	determine_inbox(activity, user)
	end)
	\|> Enum.uniq()
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	end)

	inboxes = inboxes -- priority_inboxes

	[{priority_inboxes, 0}, {inboxes, 1}]
	\|> Enum.each(fn {inboxes, priority} ->
	inboxes
	\|> Instances.filter_reachable()
	\|> Enum.each(fn inbox ->
	__MODULE__.enqueue_one(
	%{
	inbox: inbox,
	activity_id: activity.id
	},
	priority: priority
	)
	end)
	end)

	:ok
	end

	def gather_webfinger_links(%User{} = user) do
	[
	%{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
	%{
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"href" => user.ap_id
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	"template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
	}
	]
	end

	def gather_nodeinfo_protocol_names, do: ["activitypub"]
	+
	+ defp get_user_with_priority(inbox, priority_recipients, recipients) do
	+ [{priority_recipients, 0}, {recipients, 1}]
	+ \|> Enum.find_value(fn {recipients, priority} ->
	+ with %User{} = user <- Enum.find(recipients, fn actor -> actor.inbox == inbox end) do
	+ {user, priority}
	+ else
	+ _ -> nil
	+ end
	+ end)
	+ end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/account_operation.ex b/lib/pleroma/web/api_spec/operations/account_operation.ex
	index 5a19e0fbb..620fd171b 100644
	--- a/lib/pleroma/web/api_spec/operations/account_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/account_operation.ex
	@@ -1,1033 +1,1055 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.AccountOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Reference
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.AccountRelationship
	alias Pleroma.Web.ApiSpec.Schemas.ActorType
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.Schemas.List
	alias Pleroma.Web.ApiSpec.Schemas.Status
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	import Pleroma.Web.ApiSpec.Helpers

	@spec open_api_operation(atom) :: Operation.t()
	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	@spec create_operation() :: Operation.t()
	def create_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Register an account",
	description:
	"Creates a user and account records. Returns an account access token for the app that initiated the request. The app should save this token for later, and should wait for the user to confirm their account by clicking a link in their email inbox.",
	operationId: "AccountController.create",
	requestBody: request_body("Parameters", create_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", create_response()),
	400 => Operation.response("Error", "application/json", ApiError),
	403 => Operation.response("Error", "application/json", ApiError),
	429 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def verify_credentials_operation do
	%Operation{
	tags: ["Account credentials"],
	description: "Test to make sure that the user token works.",
	summary: "Verify account credentials",
	operationId: "AccountController.verify_credentials",
	security: [%{"oAuth" => ["read:accounts"]}],
	responses: %{
	200 => Operation.response("Account", "application/json", Account)
	}
	}
	end

	def update_credentials_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Update account credentials",
	description: "Update the user's display and preferences.",
	operationId: "AccountController.update_credentials",
	security: [%{"oAuth" => ["write:accounts"]}],
	requestBody: request_body("Parameters", update_credentials_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", Account),
	403 => Operation.response("Error", "application/json", ApiError),
	413 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def relationships_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Relationship with current account",
	operationId: "AccountController.relationships",
	description: "Find out whether a given account is followed, blocked, muted, etc.",
	security: [%{"oAuth" => ["read:follows"]}],
	parameters: [
	Operation.parameter(
	:id,
	:query,
	%Schema{
	oneOf: [%Schema{type: :array, items: %Schema{type: :string}}, %Schema{type: :string}]
	},
	"Account IDs",
	example: "123"
	)
	],
	responses: %{
	200 => Operation.response("Account", "application/json", array_of_relationships())
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Account",
	operationId: "AccountController.show",
	description: "View information about a profile.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	with_relationships_param()
	],
	responses: %{
	200 => Operation.response("Account", "application/json", Account),
	401 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def statuses_operation do
	%Operation{
	summary: "Statuses",
	tags: ["Retrieve account information"],
	operationId: "AccountController.statuses",
	description:
	"Statuses posted to the given account. Public (for public statuses only), or user token + `read:statuses` (for private statuses the user is authorized to see)",
	parameters:
	[
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(
	:pinned,
	:query,
	BooleanLike.schema(),
	"Include only pinned statuses"
	),
	Operation.parameter(:tagged, :query, :string, "With tag"),
	Operation.parameter(
	:only_media,
	:query,
	BooleanLike.schema(),
	"Include only statuses with media attached"
	),
	Operation.parameter(
	:with_muted,
	:query,
	BooleanLike.schema(),
	"Include statuses from muted accounts."
	),
	Operation.parameter(:exclude_reblogs, :query, BooleanLike.schema(), "Exclude reblogs"),
	Operation.parameter(
	:only_reblogs,
	:query,
	BooleanLike.schema(),
	"Include only reblogs"
	),
	Operation.parameter(:exclude_replies, :query, BooleanLike.schema(), "Exclude replies"),
	Operation.parameter(
	:exclude_visibilities,
	:query,
	%Schema{type: :array, items: VisibilityScope},
	"Exclude visibilities"
	),
	Operation.parameter(
	:with_muted,
	:query,
	BooleanLike.schema(),
	"Include reactions from muted accounts."
	)
	] ++ pagination_params(),
	responses: %{
	200 => Operation.response("Statuses", "application/json", array_of_statuses()),
	401 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def followers_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Followers",
	operationId: "AccountController.followers",
	security: [%{"oAuth" => ["read:accounts"]}],
	description:
	"Accounts which follow the given account, if network is not hidden by the account owner.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(:id, :query, :string, "ID of the resource owner"),
	with_relationships_param() \| pagination_params()
	],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def following_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Following",
	operationId: "AccountController.following",
	security: [%{"oAuth" => ["read:accounts"]}],
	description:
	"Accounts which the given account is following, if network is not hidden by the account owner.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(:id, :query, :string, "ID of the resource owner"),
	with_relationships_param() \| pagination_params()
	],
	responses: %{200 => Operation.response("Accounts", "application/json", array_of_accounts())}
	}
	end

	def lists_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Lists containing this account",
	operationId: "AccountController.lists",
	security: [%{"oAuth" => ["read:lists"]}],
	description: "User lists that you have added this account to.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{200 => Operation.response("Lists", "application/json", array_of_lists())}
	}
	end

	def follow_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Follow",
	operationId: "AccountController.follow",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	description: "Follow the given account",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
	],
	requestBody:
	request_body(
	"Parameters",
	%Schema{
	type: :object,
	properties: %{
	reblogs: %Schema{
	allOf: [BooleanLike],
	description: "Receive this account's reblogs in home timeline? Defaults to true.",
	default: true
	},
	notify: %Schema{
	allOf: [BooleanLike],
	description:
	"Receive notifications for all statuses posted by the account? Defaults to false.",
	default: false
	}
	}
	},
	required: false
	),
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def unfollow_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Unfollow",
	operationId: "AccountController.unfollow",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	description: "Unfollow the given account",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def mute_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Mute",
	operationId: "AccountController.mute",
	security: [%{"oAuth" => ["follow", "write:mutes"]}],
	requestBody: request_body("Parameters", mute_request()),
	description:
	"Mute the given account. Clients should filter statuses and notifications from this account, if received (e.g. due to a boost in the Home timeline).",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(
	:notifications,
	:query,
	%Schema{allOf: [BooleanLike], default: true},
	"Mute notifications in addition to statuses? Defaults to `true`."
	)
	],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def unmute_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Unmute",
	operationId: "AccountController.unmute",
	security: [%{"oAuth" => ["follow", "write:mutes"]}],
	description: "Unmute the given account.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def block_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Block",
	operationId: "AccountController.block",
	requestBody: request_body("Parameters", block_request()),
	security: [%{"oAuth" => ["follow", "write:blocks"]}],
	description:
	"Block the given account. Clients should filter statuses from this account if received (e.g. due to a boost in the Home timeline)",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
	],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	defp block_request do
	%Schema{
	title: "AccountBlockRequest",
	description: "POST body for blocking an account",
	type: :object,
	properties: %{
	duration: %Schema{
	type: :integer,
	nullable: true,
	description: "Expire the mute in `duration` seconds. Default 0 for infinity"
	}
	},
	example: %{
	"duration" => 86_400
	}
	}
	end

	def unblock_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Unblock",
	operationId: "AccountController.unblock",
	security: [%{"oAuth" => ["follow", "write:blocks"]}],
	description: "Unblock the given account.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def endorse_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Endorse",
	operationId: "AccountController.endorse",
	security: [%{"oAuth" => ["follow", "write:accounts"]}],
	description: "Adds the given account to endorsed accounts list.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 =>
	Operation.response("Bad Request", "application/json", %Schema{
	allOf: [ApiError],
	title: "Unprocessable Entity",
	example: %{
	"error" => "You have already pinned the maximum number of users"
	}
	})
	}
	}
	end

	def unendorse_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Unendorse",
	operationId: "AccountController.unendorse",
	security: [%{"oAuth" => ["follow", "write:accounts"]}],
	description: "Removes the given account from endorsed accounts list.",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	+ def endorsements_operation do
	+ %Operation{
	+ tags: ["Retrieve account information"],
	+ summary: "Endorsements",
	+ description: "Returns endorsed accounts",
	+ operationId: "AccountController.endorsements",
	+ parameters: [
	+ with_relationships_param(),
	+ %Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
	+ ],
	+ responses: %{
	+ 200 =>
	+ Operation.response(
	+ "Array of Accounts",
	+ "application/json",
	+ array_of_accounts()
	+ ),
	+ 404 => Operation.response("Not Found", "application/json", ApiError)
	+ }
	+ }
	+ end
	+
	def remove_from_followers_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Remove from followers",
	operationId: "AccountController.remove_from_followers",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	description: "Remove the given account from followers",
	parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def note_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Set a private note about a user.",
	operationId: "AccountController.note",
	security: [%{"oAuth" => ["follow", "write:accounts"]}],
	requestBody: request_body("Parameters", note_request()),
	description: "Create a note for the given account.",
	parameters: [
	%Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
	Operation.parameter(
	:comment,
	:query,
	%Schema{type: :string},
	"Account note body"
	)
	],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship)
	}
	}
	end

	def follow_by_uri_operation do
	%Operation{
	tags: ["Account actions"],
	summary: "Follow by URI",
	operationId: "AccountController.follows",
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	requestBody: request_body("Parameters", follow_by_uri_request(), required: true),
	responses: %{
	200 => Operation.response("Account", "application/json", AccountRelationship),
	400 => Operation.response("Error", "application/json", ApiError),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def mutes_operation do
	%Operation{
	tags: ["Blocks and mutes"],
	summary: "Retrieve list of mutes",
	operationId: "AccountController.mutes",
	description: "Accounts the user has muted.",
	security: [%{"oAuth" => ["follow", "read:mutes"]}],
	parameters: [with_relationships_param() \| pagination_params()],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def blocks_operation do
	%Operation{
	tags: ["Blocks and mutes"],
	summary: "Retrieve list of blocks",
	operationId: "AccountController.blocks",
	description: "View your blocks. See also accounts/:id/{block,unblock}",
	security: [%{"oAuth" => ["read:blocks"]}],
	parameters: [with_relationships_param() \| pagination_params()],
	responses: %{
	200 => Operation.response("Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def lookup_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Find a user by nickname",
	operationId: "AccountController.lookup",
	parameters: [
	Operation.parameter(
	:acct,
	:query,
	:string,
	"User nickname"
	)
	],
	responses: %{
	200 => Operation.response("Account", "application/json", Account),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	- def endorsements_operation do
	+ def own_endorsements_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Endorsements",
	- operationId: "AccountController.endorsements",
	+ operationId: "AccountController.own_endorsements",
	description: "Returns endorsed accounts",
	security: [%{"oAuth" => ["read:accounts"]}],
	responses: %{
	200 => Operation.response("Array of Accounts", "application/json", array_of_accounts())
	}
	}
	end

	def familiar_followers_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Followers that you follow",
	operationId: "AccountController.familiar_followers",
	description:
	"Obtain a list of all accounts that follow a given account, filtered for accounts you follow.",
	security: [%{"oAuth" => ["read:follows"]}],
	parameters: [
	Operation.parameter(
	:id,
	:query,
	%Schema{
	oneOf: [%Schema{type: :array, items: %Schema{type: :string}}, %Schema{type: :string}]
	},
	"Account IDs",
	example: "123"
	)
	],
	responses: %{
	200 =>
	Operation.response("Accounts", "application/json", %Schema{
	title: "ArrayOfAccounts",
	type: :array,
	items: %Schema{
	title: "Account",
	type: :object,
	properties: %{
	id: FlakeID,
	accounts: %Schema{
	title: "ArrayOfAccounts",
	type: :array,
	items: Account,
	example: [Account.schema().example]
	}
	}
	}
	})
	}
	}
	end

	defp create_request do
	%Schema{
	title: "AccountCreateRequest",
	description: "POST body for creating an account",
	type: :object,
	required: [:username, :password, :agreement],
	properties: %{
	reason: %Schema{
	type: :string,
	nullable: true,
	description:
	"Text that will be reviewed by moderators if registrations require manual approval"
	},
	username: %Schema{type: :string, description: "The desired username for the account"},
	email: %Schema{
	type: :string,
	nullable: true,
	description:
	"The email address to be used for login. Required when `account_activation_required` is enabled.",
	format: :email
	},
	password: %Schema{
	type: :string,
	description: "The password to be used for login",
	format: :password
	},
	agreement: %Schema{
	allOf: [BooleanLike],
	description:
	"Whether the user agrees to the local rules, terms, and policies. These should be presented to the user in order to allow them to consent before setting this parameter to TRUE."
	},
	locale: %Schema{
	type: :string,
	nullable: true,
	description: "The language of the confirmation email that will be sent"
	},
	# Pleroma-specific properties:
	fullname: %Schema{type: :string, nullable: true, description: "Full name"},
	bio: %Schema{type: :string, description: "Bio", nullable: true, default: ""},
	captcha_solution: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha solution"
	},
	captcha_token: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha token"
	},
	captcha_answer_data: %Schema{
	type: :string,
	nullable: true,
	description: "Provider-specific captcha data"
	},
	token: %Schema{
	type: :string,
	nullable: true,
	description: "Invite token required when the registrations aren't public"
	},
	birthday: %Schema{
	nullable: true,
	description: "User's birthday",
	anyOf: [
	%Schema{
	type: :string,
	format: :date
	},
	%Schema{
	type: :string,
	maxLength: 0
	}
	]
	},
	language: %Schema{
	type: :string,
	nullable: true,
	description: "User's preferred language for emails"
	}
	},
	example: %{
	"username" => "cofe",
	"email" => "cofe@example.com",
	"password" => "secret",
	"agreement" => "true",
	"bio" => "☕️"
	}
	}
	end

	# Note: this is a token response (if login succeeds!), but there's no oauth operation file yet.
	defp create_response do
	%Schema{
	title: "AccountCreateResponse",
	description: "Response schema for an account",
	type: :object,
	properties: %{
	# The response when auto-login on create succeeds (token is issued):
	token_type: %Schema{type: :string},
	access_token: %Schema{type: :string},
	refresh_token: %Schema{type: :string},
	scope: %Schema{type: :string},
	created_at: %Schema{type: :integer, format: :"date-time"},
	me: %Schema{type: :string},
	expires_in: %Schema{type: :integer},
	#
	# The response when registration succeeds but auto-login fails (no token):
	identifier: %Schema{type: :string},
	message: %Schema{type: :string}
	},
	# Note: example of successful registration with failed login response:
	# example: %{
	# "identifier" => "missing_confirmed_email",
	# "message" => "You have been registered. Please check your email for further instructions."
	# },
	example: %{
	"token_type" => "Bearer",
	"access_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzk",
	"refresh_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzz",
	"created_at" => 1_585_918_714,
	"expires_in" => 600,
	"scope" => "read write follow push",
	"me" => "https://gensokyo.2hu/users/raymoo"
	}
	}
	end

	defp update_credentials_request do
	%Schema{
	title: "AccountUpdateCredentialsRequest",
	description: "POST body for creating an account",
	type: :object,
	properties: %{
	bot: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether the account has a bot flag."
	},
	display_name: %Schema{
	type: :string,
	nullable: true,
	description: "The display name to use for the profile."
	},
	note: %Schema{type: :string, description: "The account bio."},
	avatar: %Schema{
	type: :string,
	nullable: true,
	description: "Avatar image encoded using multipart/form-data",
	format: :binary
	},
	header: %Schema{
	type: :string,
	nullable: true,
	description: "Header image encoded using multipart/form-data",
	format: :binary
	},
	locked: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether manual approval of follow requests is required."
	},
	accepts_chat_messages: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Whether the user accepts receiving chat messages."
	},
	fields_attributes: %Schema{
	nullable: true,
	oneOf: [
	%Schema{type: :array, items: attribute_field()},
	%Schema{type: :object, additionalProperties: attribute_field()}
	]
	},
	# NOTE: `source` field is not supported
	#
	# source: %Schema{
	# type: :object,
	# properties: %{
	# privacy: %Schema{type: :string},
	# sensitive: %Schema{type: :boolean},
	# language: %Schema{type: :string}
	# }
	# },

	# Pleroma-specific fields
	no_rich_text: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "html tags are stripped from all statuses requested from the API"
	},
	hide_followers: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's followers will be hidden"
	},
	hide_follows: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follows will be hidden"
	},
	hide_followers_count: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follower count will be hidden"
	},
	hide_follows_count: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's follow count will be hidden"
	},
	hide_favorites: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's favorites timeline will be hidden"
	},
	show_role: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "user's role (e.g admin, moderator) will be exposed to anyone in the
	API"
	},
	default_scope: VisibilityScope,
	pleroma_settings_store: %Schema{
	type: :object,
	nullable: true,
	description: "Opaque user settings to be saved on the backend."
	},
	skip_thread_containment: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Skip filtering out broken threads"
	},
	allow_following_move: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Allows automatically follow moved following accounts"
	},
	also_known_as: %Schema{
	type: :array,
	items: %Schema{type: :string},
	nullable: true,
	description: "List of alternate ActivityPub IDs"
	},
	pleroma_background_image: %Schema{
	type: :string,
	nullable: true,
	description: "Sets the background image of the user.",
	format: :binary
	},
	discoverable: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description:
	"Discovery (listing, indexing) of this account by external services (search bots etc.) is allowed."
	},
	actor_type: ActorType,
	birthday: %Schema{
	nullable: true,
	description: "User's birthday",
	anyOf: [
	%Schema{
	type: :string,
	format: :date
	},
	%Schema{
	type: :string,
	maxLength: 0
	}
	]
	},
	show_birthday: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "User's birthday will be visible"
	},
	avatar_description: %Schema{
	type: :string,
	nullable: true,
	description: "Avatar image description."
	},
	header_description: %Schema{
	type: :string,
	nullable: true,
	description: "Header image description."
	}
	},
	example: %{
	bot: false,
	display_name: "cofe",
	note: "foobar",
	fields_attributes: [%{name: "foo", value: "bar"}],
	no_rich_text: false,
	hide_followers: true,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	hide_favorites: false,
	show_role: false,
	default_scope: "private",
	pleroma_settings_store: %{"pleroma-fe" => %{"key" => "val"}},
	skip_thread_containment: false,
	allow_following_move: false,
	also_known_as: ["https://foo.bar/users/foo"],
	discoverable: false,
	actor_type: "Person",
	show_birthday: false,
	birthday: "2001-02-12"
	}
	}
	end

	def array_of_accounts do
	%Schema{
	title: "ArrayOfAccounts",
	type: :array,
	items: Account,
	example: [Account.schema().example]
	}
	end

	defp array_of_relationships do
	%Schema{
	title: "ArrayOfRelationships",
	description: "Response schema for account relationships",
	type: :array,
	items: AccountRelationship,
	example: [
	%{
	"id" => "1",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => false,
	"blocked_by" => true,
	"muting" => false,
	"muting_notifications" => false,
	"note" => "",
	"requested" => false,
	"domain_blocking" => false,
	"subscribing" => false,
	"notifying" => false,
	"endorsed" => true
	},
	%{
	"id" => "2",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => false,
	"blocked_by" => true,
	"muting" => true,
	"muting_notifications" => false,
	"note" => "",
	"requested" => true,
	"domain_blocking" => false,
	"subscribing" => false,
	"notifying" => false,
	"endorsed" => false
	},
	%{
	"id" => "3",
	"following" => true,
	"showing_reblogs" => true,
	"followed_by" => true,
	"blocking" => true,
	"blocked_by" => false,
	"muting" => true,
	"muting_notifications" => false,
	"note" => "",
	"requested" => false,
	"domain_blocking" => true,
	"subscribing" => true,
	"notifying" => true,
	"endorsed" => false
	}
	]
	}
	end

	defp follow_by_uri_request do
	%Schema{
	title: "AccountFollowsRequest",
	description: "POST body for muting an account",
	type: :object,
	properties: %{
	uri: %Schema{type: :string, nullable: true, format: :uri}
	},
	required: [:uri]
	}
	end

	defp mute_request do
	%Schema{
	title: "AccountMuteRequest",
	description: "POST body for muting an account",
	type: :object,
	properties: %{
	notifications: %Schema{
	allOf: [BooleanLike],
	nullable: true,
	description: "Mute notifications in addition to statuses? Defaults to true.",
	default: true
	},
	duration: %Schema{
	type: :integer,
	nullable: true,
	description: "Expire the mute in `expires_in` seconds. Default 0 for infinity"
	},
	expires_in: %Schema{
	type: :integer,
	nullable: true,
	description: "Deprecated, use `duration` instead",
	default: 0
	}
	},
	example: %{
	"notifications" => true,
	"expires_in" => 86_400
	}
	}
	end

	defp note_request do
	%Schema{
	title: "AccountNoteRequest",
	description: "POST body for adding a note for an account",
	type: :object,
	properties: %{
	comment: %Schema{
	type: :string,
	description: "Account note body"
	}
	},
	example: %{
	"comment" => "Example note"
	}
	}
	end

	defp array_of_lists do
	%Schema{
	title: "ArrayOfLists",
	description: "Response schema for lists",
	type: :array,
	items: List,
	example: [
	%{"id" => "123", "title" => "my list"},
	%{"id" => "1337", "title" => "anotehr list"}
	]
	}
	end

	defp array_of_statuses do
	%Schema{
	title: "ArrayOfStatuses",
	type: :array,
	items: Status
	}
	end

	defp attribute_field do
	%Schema{
	title: "AccountAttributeField",
	description: "Request schema for account custom fields",
	type: :object,
	properties: %{
	name: %Schema{type: :string},
	value: %Schema{type: :string}
	},
	required: [:name, :value],
	example: %{
	"name" => "Website",
	"value" => "https://pleroma.com"
	}
	}
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/pleroma_account_operation.ex b/lib/pleroma/web/api_spec/operations/pleroma_account_operation.ex
	index b8b37d7cf..b144c2ac0 100644
	--- a/lib/pleroma/web/api_spec/operations/pleroma_account_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/pleroma_account_operation.ex
	@@ -1,154 +1,135 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.PleromaAccountOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.AccountOperation
	alias Pleroma.Web.ApiSpec.Schemas.AccountRelationship
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.FlakeID
	alias Pleroma.Web.ApiSpec.StatusOperation

	import Pleroma.Web.ApiSpec.Helpers

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

	def confirmation_resend_operation do
	%Operation{
	tags: ["Account credentials"],
	summary: "Resend confirmation email",
	description: "Expects `email` or `nickname`.",
	operationId: "PleromaAPI.AccountController.confirmation_resend",
	parameters: [
	Operation.parameter(:email, :query, :string, "Email of that needs to be verified",
	example: "cofe@cofe.io"
	),
	Operation.parameter(
	:nickname,
	:query,
	:string,
	"Nickname of user that needs to be verified",
	example: "cofefe"
	)
	],
	responses: %{
	204 => no_content_response()
	}
	}
	end

	def favourites_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Favorites",
	description:
	"Only returns data if the user has opted into sharing it. See `hide_favorites` in [Update account credentials](#operation/AccountController.update_credentials).",
	operationId: "PleromaAPI.AccountController.favourites",
	parameters: [id_param() \| pagination_params()],
	security: [%{"oAuth" => ["read:favourites"]}],
	responses: %{
	200 =>
	Operation.response(
	"Array of Statuses",
	"application/json",
	StatusOperation.array_of_statuses()
	),
	403 => Operation.response("Forbidden", "application/json", ApiError),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	- def endorsements_operation do
	- %Operation{
	- tags: ["Retrieve account information"],
	- summary: "Endorsements",
	- description: "Returns endorsed accounts",
	- operationId: "PleromaAPI.AccountController.endorsements",
	- parameters: [with_relationships_param(), id_param()],
	- responses: %{
	- 200 =>
	- Operation.response(
	- "Array of Accounts",
	- "application/json",
	- AccountOperation.array_of_accounts()
	- ),
	- 404 => Operation.response("Not Found", "application/json", ApiError)
	- }
	- }
	- end
	-
	def subscribe_operation do
	%Operation{
	deprecated: true,
	tags: ["Account actions"],
	summary: "Subscribe",
	description:
	"Receive notifications for all statuses posted by the account. Deprecated, use `notify: true` in follow operation instead.",
	operationId: "PleromaAPI.AccountController.subscribe",
	parameters: [id_param()],
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def unsubscribe_operation do
	%Operation{
	deprecated: true,
	tags: ["Account actions"],
	summary: "Unsubscribe",
	description:
	"Stop receiving notifications for all statuses posted by the account. Deprecated, use `notify: false` in follow operation instead.",
	operationId: "PleromaAPI.AccountController.unsubscribe",
	parameters: [id_param()],
	security: [%{"oAuth" => ["follow", "write:follows"]}],
	responses: %{
	200 => Operation.response("Relationship", "application/json", AccountRelationship),
	404 => Operation.response("Not Found", "application/json", ApiError)
	}
	}
	end

	def birthdays_operation do
	%Operation{
	tags: ["Retrieve account information"],
	summary: "Birthday reminders",
	description: "Birthday reminders about users you follow.",
	operationId: "PleromaAPI.AccountController.birthdays",
	parameters: [
	Operation.parameter(
	:day,
	:query,
	%Schema{type: :integer},
	"Day of users' birthdays"
	),
	Operation.parameter(
	:month,
	:query,
	%Schema{type: :integer},
	"Month of users' birthdays"
	)
	],
	security: [%{"oAuth" => ["read:accounts"]}],
	responses: %{
	200 =>
	Operation.response("Accounts", "application/json", AccountOperation.array_of_accounts())
	}
	}
	end

	defp id_param do
	Operation.parameter(:id, :path, FlakeID.schema(), "Account ID",
	example: "9umDrYheeY451cQnEe",
	required: true
	)
	end
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index 52c08f00f..91bf9c502 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,498 +1,497 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Utils do
	import Pleroma.Web.Gettext

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

	require Logger
	require Pleroma.Constants

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

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

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

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

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

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

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

	Enum.map(ids, fn media_id ->
	with %Object{data: data} <- get_attachment(media_id, user) do
	Map.put(data, "name", descs[media_id])
	end
	end)
	\|> Enum.reject(&is_nil/1)
	end

	defp get_attachment(media_id, user) do
	with %Object{data: data} = object <- Repo.get(Object, media_id),
	%{"type" => type} when type in Pleroma.Constants.upload_object_types() <- data,
	:ok <- Object.authorize_access(object, user) do
	object
	else
	_ -> nil
	end
	end

	@spec get_to_and_cc(ActivityDraft.t()) :: {list(String.t()), list(String.t())}

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

	def get_to_and_cc(%{visibility: visibility} = draft) when visibility in ["public", "local"] do
	to =
	case visibility do
	"public" -> [Pleroma.Constants.as_public() \| draft.mentions]
	"local" -> [Utils.as_local_public() \| draft.mentions]
	end

	cc = [draft.user.follower_address]

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

	def get_to_and_cc(%{visibility: "unlisted"} = draft) do
	to = [draft.user.follower_address \| draft.mentions]
	cc = [Pleroma.Constants.as_public()]

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

	def get_to_and_cc(%{visibility: "private"} = draft) do
	{to, cc} = get_to_and_cc(struct(draft, visibility: "direct"))
	{[draft.user.follower_address \| to], cc}
	end

	def get_to_and_cc(%{visibility: "direct"} = draft) do
	# If the OP is a DM already, add the implicit actor.
	if draft.in_reply_to && Visibility.direct?(draft.in_reply_to) do
	{Enum.uniq([draft.in_reply_to.data["actor"] \| draft.mentions]), []}
	else
	{draft.mentions, []}
	end
	end

	def get_to_and_cc(%{visibility: {:list, _}, mentions: mentions}), do: {mentions, []}

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

	def get_addressed_users(mentioned_users, _), do: mentioned_users

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

	_ ->
	activity_params
	end
	end

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

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

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

	options = options \|> Enum.uniq()

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

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

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

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

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

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

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

	defp validate_poll_options_amount(options, %{max_options: max_options}) do
	cond do
	Enum.count(options) < 2 ->
	{:error, "Poll must contain at least 2 options"}

	Enum.count(options) > max_options ->
	{:error, "Poll can't contain more than #{max_options} options"}

	true ->
	:ok
	end
	end

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

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

	def make_content_html(%ActivityDraft{} = draft) do
	attachment_links =
	draft.params
	\|> Map.get("attachment_links", Config.get([:instance, :attachment_links]))
	\|> Params.truthy_param?()

	content_type = get_content_type(draft.params[:content_type])

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

	draft.status
	\|> format_input(content_type, options)
	\|> maybe_add_attachments(draft.attachments, attachment_links)
	end

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

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

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

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

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

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

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

	defp build_attachment_link(_), do: ""

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

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

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

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

	def format_input(text, "text/markdown", options) do
	text
	\|> Formatter.mentions_escape(options)
	\|> Formatter.markdown_to_html()
	\|> Formatter.linkify(options)
	\|> Formatter.html_escape("text/html")
	end

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

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

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

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

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

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

	def to_masto_date(_), do: ""

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

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

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

	def maybe_notify_to_recipients(recipients, _), do: recipients

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

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

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

	true ->
	%{}
	end

	tagged_mentions = maybe_extract_mentions(object_data)

	recipients ++ tagged_mentions
	end

	def maybe_notify_mentioned_recipients(recipients, _), do: recipients

	- def maybe_notify_subscribers(
	- recipients,
	+ def maybe_notify_followers(recipients, %Activity{data: %{"type" => "Move"}} = activity) do
	+ with %User{} = user <- User.get_cached_by_ap_id(activity.actor) do
	+ user
	+ \|> User.get_followers()
	+ \|> Enum.map(& &1.ap_id)
	+ \|> Enum.concat(recipients)
	+ else
	+ _e -> recipients
	+ end
	+ end
	+
	+ def maybe_notify_followers(recipients, _), do: recipients
	+
	+ def get_notified_subscribers(
	%Activity{data: %{"actor" => actor, "type" => "Create"}} = activity
	) do
	# Do not notify subscribers if author is making a reply
	with %Object{data: object} <- Object.normalize(activity, fetch: false),
	nil <- object["inReplyTo"],
	%User{} = user <- User.get_cached_by_ap_id(actor) do
	subscriber_ids =
	user
	\|> User.subscriber_users()
	\|> Enum.filter(&Visibility.visible_for_user?(activity, &1))
	\|> Enum.map(& &1.ap_id)

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

	- def maybe_notify_followers(recipients, _), do: recipients
	+ def get_notified_subscribers(_), do: []

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

	def maybe_extract_mentions(_), do: []

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

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

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

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

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

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

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

	if length <= limit do
	:ok
	else
	{:error, dgettext("errors", "The status is over the character limit")}
	end
	end

	def validate_attachments_count([] = _attachments) do
	:ok
	end

	def validate_attachments_count(attachments) do
	limit = Config.get([:instance, :max_media_attachments])
	count = length(attachments)

	if count <= limit do
	:ok
	else
	{:error, dgettext("errors", "Too many attachments")}
	end
	end
	end
	diff --git a/lib/pleroma/web/feed/user_controller.ex b/lib/pleroma/web/feed/user_controller.ex
	index 304313068..8a52d98e0 100644
	--- a/lib/pleroma/web/feed/user_controller.ex
	+++ b/lib/pleroma/web/feed/user_controller.ex
	@@ -1,80 +1,83 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Config
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ActivityPubController
	alias Pleroma.Web.Feed.FeedView

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

	action_fallback(:errors)

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

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

	- def feed_redirect(conn, %{"nickname" => nickname}) do
	+ def feed_redirect(%{assigns: assigns} = conn, %{"nickname" => nickname}) do
	+ format = Map.get(assigns, :format, "atom")
	+ format = if format in ["atom", "rss"], do: format, else: "atom"
	+
	with {_, %User{} = user} <- {:fetch_user, User.get_cached_by_nickname(nickname)} do
	- redirect(conn, external: "#{Routes.user_feed_url(conn, :feed, user.nickname)}.atom")
	+ redirect(conn, external: "#{Routes.user_feed_url(conn, :feed, user.nickname)}.#{format}")
	end
	end

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

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

	with {_, %User{local: true} = user} <- {:fetch_user, User.get_cached_by_nickname(nickname)},
	{_, :visible} <- {:visibility, User.visible_for(user, _reading_user = nil)} do
	activities =
	%{
	type: ["Create"],
	actor_id: user.ap_id
	}
	\|> Pleroma.Maps.put_if_present(:max_id, params["max_id"])
	\|> ActivityPub.fetch_public_or_unlisted_activities()

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

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

	def errors(conn, {:fetch_user, %User{local: false}}), do: errors(conn, {:error, :not_found})
	def errors(conn, {:fetch_user, nil}), do: errors(conn, {:error, :not_found})

	def errors(conn, {:visibility, _}), do: errors(conn, {:error, :not_found})

	def errors(conn, _) do
	render_error(conn, :internal_server_error, "Something went wrong")
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	index d374e8c01..c2f8e9d07 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/account_controller.ex
	@@ -1,677 +1,693 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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,
	assign_account_by_id: 2,
	embed_relationships?: 1,
	json_response: 3
	]

	alias Pleroma.Maps
	alias Pleroma.User
	alias Pleroma.UserNote
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.ListView
	alias Pleroma.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.OAuth.OAuthController
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.Utils.Params

	plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)

	plug(:skip_auth when action in [:create, :lookup])

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

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

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

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

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:accounts"]}
	when action in [:update_credentials, :note, :endorse, :unendorse]
	)

	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 in [:relationships, :familiar_followers]
	)

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

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

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

	@relationship_actions [:follow, :unfollow, :remove_from_followers]
	@needs_account ~W(
	followers following lists follow unfollow mute unmute block unblock
	- note endorse unendorse remove_from_followers
	+ note endorse unendorse endorsements remove_from_followers
	)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}, private: %{open_api_spex: %{body_params: params}}} = conn,
	_params
	) do
	with :ok <- validate_email_param(params),
	:ok <- TwitterAPI.validate_captcha(app, params),
	{:ok, user} <- TwitterAPI.register_user(params),
	{_, {:ok, token}} <-
	{:login, OAuthController.login(user, app, app.scopes)} do
	OAuthController.after_token_exchange(conn, %{user: user, token: token})
	else
	{:login, {:account_status, :confirmation_pending}} ->
	json_response(conn, :ok, %{
	message: "You have been registered. Please check your email for further instructions.",
	identifier: "missing_confirmed_email"
	})

	{:login, {:account_status, :approval_pending}} ->
	json_response(conn, :ok, %{
	message:
	"You have been registered. You'll be able to log in once your account is approved.",
	identifier: "awaiting_approval"
	})

	{:login, _} ->
	json_response(conn, :ok, %{
	message:
	"You have been registered. Some post-registration steps may be pending. " <>
	"Please log in manually.",
	identifier: "manual_login_required"
	})

	{: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}, private: %{open_api_spex: %{body_params: params}}} = conn,
	_params
	) do
	params =
	params
	\|> Enum.filter(fn {_, value} -> not is_nil(value) end)
	\|> Enum.into(%{})

	# We use an empty string as a special value to reset
	# avatars, banners, backgrounds
	user_image_value = fn
	"" -> {:ok, nil}
	value -> {:ok, value}
	end

	user_params =
	[
	:no_rich_text,
	:hide_followers_count,
	:hide_follows_count,
	:hide_followers,
	:hide_follows,
	:hide_favorites,
	:show_role,
	:skip_thread_containment,
	:allow_following_move,
	:also_known_as,
	:accepts_chat_messages,
	:show_birthday
	]
	\|> Enum.reduce(%{}, fn key, acc ->
	Maps.put_if_present(acc, key, params[key], &{:ok, Params.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], user_image_value)
	\|> Maps.put_if_present(:banner, params[:header], user_image_value)
	\|> Maps.put_if_present(:background, params[:pleroma_background_image], user_image_value)
	\|> 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[:bot], fn bot ->
	if bot, do: {:ok, "Service"}, else: {:ok, "Person"}
	end)
	\|> Maps.put_if_present(:actor_type, params[:actor_type])
	\|> Maps.put_if_present(:also_known_as, params[:also_known_as])
	# Note: param name is indeed :locked (not an error)
	\|> Maps.put_if_present(:is_locked, params[:locked])
	# Note: param name is indeed :discoverable (not an error)
	\|> Maps.put_if_present(:is_discoverable, params[:discoverable])
	\|> Maps.put_if_present(:birthday, params[:birthday])
	\|> Maps.put_if_present(:language, Pleroma.Web.Gettext.normalize_locale(params[:language]))
	\|> Maps.put_if_present(:avatar_description, params[:avatar_description])
	\|> Maps.put_if_present(:header_description, params[:header_description])

	# What happens here:
	#
	# We want to update the user through the pipeline, but the ActivityPub
	# update information is not quite enough for this, because this also
	# contains local settings that don't federate and don't even appear
	# in the Update activity.
	#
	# So we first build the normal local changeset, then apply it to the
	# user data, but don't persist it. With this, we generate the object
	# data for our update activity. We feed this and the changeset as meta
	# information into the pipeline, where they will be properly updated and
	# federated.
	with changeset <- User.update_changeset(user, user_params),
	{:ok, unpersisted_user} <- Ecto.Changeset.apply_action(changeset, :update),
	updated_object <-
	Pleroma.Web.ActivityPub.UserView.render("user.json", user: unpersisted_user)
	\|> Map.delete("@context"),
	{:ok, update_data, []} <- Builder.update(user, updated_object),
	{:ok, _update, _} <-
	Pipeline.common_pipeline(update_data,
	local: true,
	user_update_changeset: changeset
	) do
	render(conn, "show.json",
	user: unpersisted_user,
	for: unpersisted_user,
	with_pleroma_settings: true
	)
	else
	{:error, %Ecto.Changeset{errors: [avatar: {"file is too large", _}]}} ->
	render_error(conn, :request_entity_too_large, "File is too large")

	{:error, %Ecto.Changeset{errors: [banner: {"file is too large", _}]}} ->
	render_error(conn, :request_entity_too_large, "File is too large")

	{:error, %Ecto.Changeset{errors: [background: {"file is too large", _}]}} ->
	render_error(conn, :request_entity_too_large, "File is too large")

	{:error, %Ecto.Changeset{errors: [{:bio, {_, _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "Bio is too long")

	{:error, %Ecto.Changeset{errors: [{:name, {_, _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "Name is too long")

	{:error, %Ecto.Changeset{errors: [{:avatar_description, {_, _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "Avatar description is too long")

	{:error, %Ecto.Changeset{errors: [{:header_description, {_, _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "Banner description is too long")

	{:error, %Ecto.Changeset{errors: [{:fields, {"invalid", _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "One or more field entries are too long")

	{:error, %Ecto.Changeset{errors: [{:fields, {_, _}} \| _]}} ->
	render_error(conn, :request_entity_too_large, "Too many field entries")

	_e ->
	render_error(conn, :forbidden, "Invalid request")
	end
	end

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

	@doc "GET /api/v1/accounts/relationships"
	def relationships(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_
	) 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},
	private: %{open_api_spex: %{params: %{id: nickname_or_id} = params}}
	} = conn,
	_params
	) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id, for: for_user),
	:visible <- User.visible_for(user, for_user) do
	render(conn, "show.json",
	user: user,
	for: for_user,
	embed_relationships: embed_relationships?(params)
	)
	else
	error -> user_visibility_error(conn, error)
	end
	end

	@doc "GET /api/v1/accounts/:id/statuses"
	def statuses(
	%{assigns: %{user: reading_user}, private: %{open_api_spex: %{params: params}}} = conn,
	_params
	) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(params.id, for: reading_user),
	:visible <- 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,
	with_muted: Map.get(params, :with_muted, false)
	)
	else
	error -> user_visibility_error(conn, error)
	end
	end

	defp user_visibility_error(conn, error) do
	case error do
	:restrict_unauthenticated ->
	render_error(conn, :unauthorized, "This API requires an authenticated user")

	_ ->
	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}, private: %{open_api_spex: %{params: params}}} =
	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}, private: %{open_api_spex: %{params: params}}} =
	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},
	private: %{open_api_spex: %{body_params: params}}
	} = conn,
	_
	) 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(followed, follower) 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},
	private: %{open_api_spex: %{body_params: params}}
	} = conn,
	_params
	) do
	params =
	params
	\|> Map.put_new(:duration, Map.get(params, :expires_in, 0))

	with {:ok, _user_relationships} <- User.mute(muter, muted, params) 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},
	private: %{open_api_spex: %{body_params: params}}
	} = conn,
	_params
	) do
	with {:ok, _activity} <- CommonAPI.block(blocked, blocker, params) 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(blocked, blocker) 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/note"
	def note(
	%{
	assigns: %{user: noter, account: target},
	private: %{open_api_spex: %{body_params: %{comment: comment}}}
	} = conn,
	_params
	) do
	with {:ok, _user_note} <- UserNote.create(noter, target, comment) do
	render(conn, "relationship.json", user: noter, target: target)
	end
	end

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

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

	+ @doc "GET /api/v1/accounts/:id/endorsements"
	+ def endorsements(%{assigns: %{user: for_user, account: user}} = conn, params) do
	+ users =
	+ user
	+ \|> User.endorsed_users_relation(_restrict_deactivated = true)
	+ \|> Pleroma.Repo.all()
	+
	+ conn
	+ \|> render("index.json",
	+ for: for_user,
	+ users: users,
	+ as: :user,
	+ embed_relationships: embed_relationships?(params)
	+ )
	+ end
	+
	@doc "POST /api/v1/accounts/:id/remove_from_followers"
	def remove_from_followers(%{assigns: %{user: %{id: id}, account: %{id: id}}}, _params) do
	{:error, "Can not unfollow yourself"}
	end

	def remove_from_followers(%{assigns: %{user: followed, account: follower}} = conn, _params) do
	with {:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
	render(conn, "relationship.json", user: followed, target: follower)
	else
	nil ->
	render_error(conn, :not_found, "Record not found")
	end
	end

	@doc "POST /api/v1/follows"
	def follow_by_uri(%{private: %{open_api_spex: %{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, params) do
	users =
	user
	\|> User.muted_users_relation(_restrict_deactivated = true)
	\|> Pleroma.Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(users)
	\|> render("index.json",
	users: users,
	for: user,
	as: :user,
	embed_relationships: embed_relationships?(params),
	mutes: true
	)
	end

	@doc "GET /api/v1/blocks"
	def blocks(%{assigns: %{user: user}} = conn, params) do
	users =
	user
	\|> User.blocked_users_relation(_restrict_deactivated = true)
	\|> Pleroma.Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(users)
	\|> render("index.json",
	users: users,
	for: user,
	as: :user,
	embed_relationships: embed_relationships?(params),
	blocks: true
	)
	end

	@doc "GET /api/v1/accounts/lookup"
	def lookup(%{private: %{open_api_spex: %{params: %{acct: nickname}}}} = conn, _params) do
	with %User{} = user <- User.get_by_nickname(nickname) do
	render(conn, "show.json",
	user: user,
	skip_visibility_check: true
	)
	else
	error -> user_visibility_error(conn, error)
	end
	end

	@doc "GET /api/v1/endorsements"
	- def endorsements(%{assigns: %{user: user}} = conn, params) do
	+ def own_endorsements(%{assigns: %{user: user}} = conn, params) do
	users =
	user
	\|> User.endorsed_users_relation(_restrict_deactivated = true)
	\|> Pleroma.Repo.all()

	conn
	\|> render("index.json",
	users: users,
	for: user,
	as: :user,
	embed_relationships: embed_relationships?(params)
	)
	end

	@doc "GET /api/v1/accounts/familiar_followers"
	def familiar_followers(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
	_id
	) do
	users =
	User.get_all_by_ids(List.wrap(id))
	\|> Enum.map(&%{id: &1.id, accounts: get_familiar_followers(&1, user)})

	conn
	\|> render("familiar_followers.json",
	for: user,
	users: users,
	as: :user
	)
	end

	defp get_familiar_followers(%{id: id} = user, %{id: id}) do
	User.get_familiar_followers(user, user)
	end

	defp get_familiar_followers(%{hide_followers: true}, _current_user) do
	[]
	end

	defp get_familiar_followers(user, current_user) do
	User.get_familiar_followers(user, current_user)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/instance_view.ex b/lib/pleroma/web/mastodon_api/views/instance_view.ex
	index 1b6f26af7..b21383659 100644
	--- a/lib/pleroma/web/mastodon_api/views/instance_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/instance_view.ex
	@@ -1,350 +1,374 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Config
	alias Pleroma.Web.ActivityPub.MRF

	@mastodon_api_level "2.7.2"

	def render("show.json", _) do
	instance = Config.get(:instance)

	common_information(instance)
	\|> Map.merge(%{
	uri: Pleroma.Web.WebFinger.host(),
	description: Keyword.get(instance, :description),
	short_description: Keyword.get(instance, :short_description),
	email: Keyword.get(instance, :email),
	urls: %{
	streaming_api: Pleroma.Web.Endpoint.websocket_url()
	},
	stats: Pleroma.Stats.get_stats(),
	thumbnail:
	URI.merge(Pleroma.Web.Endpoint.url(), Keyword.get(instance, :instance_thumbnail))
	\|> to_string,
	registrations: Keyword.get(instance, :registrations_open),
	approval_required: Keyword.get(instance, :account_approval_required),
	contact_account: contact_account(Keyword.get(instance, :contact_username)),
	configuration: configuration(),
	# Extra (not present in Mastodon):
	max_toot_chars: Keyword.get(instance, :limit),
	max_media_attachments: Keyword.get(instance, :max_media_attachments),
	poll_limits: Keyword.get(instance, :poll_limits),
	upload_limit: Keyword.get(instance, :upload_limit),
	avatar_upload_limit: Keyword.get(instance, :avatar_upload_limit),
	background_upload_limit: Keyword.get(instance, :background_upload_limit),
	banner_upload_limit: Keyword.get(instance, :banner_upload_limit),
	background_image: Pleroma.Web.Endpoint.url() <> Keyword.get(instance, :background_image),
	shout_limit: Config.get([:shout, :limit]),
	description_limit: Keyword.get(instance, :description_limit),
	chat_limit: Keyword.get(instance, :chat_limit),
	pleroma: pleroma_configuration(instance)
	})
	end

	def render("show2.json", _) do
	instance = Config.get(:instance)

	common_information(instance)
	\|> Map.merge(%{
	domain: Pleroma.Web.WebFinger.host(),
	source_url: Pleroma.Application.repository(),
	description: Keyword.get(instance, :short_description),
	usage: %{users: %{active_month: Pleroma.User.active_user_count()}},
	thumbnail: %{
	url:
	URI.merge(Pleroma.Web.Endpoint.url(), Keyword.get(instance, :instance_thumbnail))
	\|> to_string
	},
	configuration: configuration2(),
	registrations: %{
	enabled: Keyword.get(instance, :registrations_open),
	approval_required: Keyword.get(instance, :account_approval_required),
	message: nil,
	url: nil
	},
	contact: %{
	email: Keyword.get(instance, :email),
	account: contact_account(Keyword.get(instance, :contact_username))
	},
	# Extra (not present in Mastodon):
	pleroma: pleroma_configuration2(instance)
	})
	end

	def render("rules.json", _) do
	Pleroma.Rule.query()
	\|> Pleroma.Repo.all()
	\|> render_many(__MODULE__, "rule.json", as: :rule)
	end

	def render("rule.json", %{rule: rule}) do
	%{
	id: to_string(rule.id),
	text: rule.text,
	hint: rule.hint \|\| ""
	}
	end

	def render("translation_languages.json", _) do
	with true <- Pleroma.Language.Translation.configured?(),
	{:ok, languages} <- Pleroma.Language.Translation.languages_matrix() do
	languages
	else
	_ -> %{}
	end
	end

	defp common_information(instance) do
	%{
	languages: Keyword.get(instance, :languages, ["en"]),
	rules: render(__MODULE__, "rules.json"),
	title: Keyword.get(instance, :name),
	version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})"
	}
	end

	def features do
	[
	"pleroma_api",
	"mastodon_api",
	"mastodon_api_streaming",
	"polls",
	"v2_suggestions",
	"pleroma_explicit_addressing",
	"shareable_emoji_packs",
	"multifetch",
	"pleroma:api/v1/notifications:include_types_filter",
	"editing",
	"quote_posting",
	if Config.get([:activitypub, :blockers_visible]) do
	"blockers_visible"
	end,
	if Config.get([:media_proxy, :enabled]) do
	"media_proxy"
	end,
	if Config.get([:gopher, :enabled]) do
	"gopher"
	end,
	# backwards compat
	if Config.get([:shout, :enabled]) do
	"chat"
	end,
	if Config.get([:shout, :enabled]) do
	"shout"
	end,
	if Config.get([:instance, :allow_relay]) do
	"relay"
	end,
	if Config.get([:instance, :safe_dm_mentions]) do
	"safe_dm_mentions"
	end,
	"pleroma_emoji_reactions",
	"pleroma_custom_emoji_reactions",
	"pleroma_chat_messages",
	if Config.get([:instance, :show_reactions]) do
	"exposable_reactions"
	end,
	if Config.get([:instance, :profile_directory]) do
	"profile_directory"
	end,
	"pleroma:get:main/ostatus",
	"pleroma:group_actors",
	"pleroma:bookmark_folders",
	if Pleroma.Language.LanguageDetector.configured?() do
	"pleroma:language_detection"
	end,
	"pleroma:block_expiration"
	]
	\|> Enum.filter(& &1)
	end

	def federation do
	quarantined = Config.get([:instance, :quarantined_instances], [])
	rejected = Config.get([:instance, :rejected_instances], [])

	if Config.get([:mrf, :transparency]) do
	{:ok, data} = MRF.describe()

	data
	\|> Map.put(
	:quarantined_instances,
	Enum.map(quarantined, fn {instance, _reason} -> instance end)
	)
	# This is for backwards compatibility. We originally didn't sent
	# extra info like a reason why an instance was rejected/quarantined/etc.
	# Because we didn't want to break backwards compatibility it was decided
	# to add an extra "info" key.
	\|> Map.put(:quarantined_instances_info, %{
	"quarantined_instances" =>
	quarantined
	\|> Enum.map(fn {instance, reason} -> {instance, %{"reason" => reason}} end)
	\|> Map.new()
	})
	\|> Map.put(
	:rejected_instances,
	rejected
	\|> Enum.map(fn {instance, reason} -> {instance, %{"reason" => reason}} end)
	\|> Map.new()
	)
	else
	%{}
	end
	\|> Map.put(:enabled, Config.get([:instance, :federating]))
	end

	defp fields_limits do
	%{
	max_fields: Config.get([:instance, :max_account_fields]),
	max_remote_fields: Config.get([:instance, :max_remote_account_fields]),
	name_length: Config.get([:instance, :account_field_name_length]),
	value_length: Config.get([:instance, :account_field_value_length])
	}
	end

	defp contact_account(nil), do: nil

	defp contact_account("@" <> username) do
	contact_account(username)
	end

	defp contact_account(username) do
	user = Pleroma.User.get_cached_by_nickname(username)

	if user do
	Pleroma.Web.MastodonAPI.AccountView.render("show.json", %{user: user, for: nil})
	else
	nil
	end
	end

	defp configuration do
	%{
	accounts: %{
	max_featured_tags: 0
	},
	statuses: %{
	max_characters: Config.get([:instance, :limit]),
	max_media_attachments: Config.get([:instance, :max_media_attachments])
	},
	media_attachments: %{
	image_size_limit: Config.get([:instance, :upload_limit]),
	video_size_limit: Config.get([:instance, :upload_limit]),
	supported_mime_types: ["application/octet-stream"]
	},
	polls: %{
	max_options: Config.get([:instance, :poll_limits, :max_options]),
	max_characters_per_option: Config.get([:instance, :poll_limits, :max_option_chars]),
	min_expiration: Config.get([:instance, :poll_limits, :min_expiration]),
	max_expiration: Config.get([:instance, :poll_limits, :max_expiration])
	}
	}
	end

	defp configuration2 do
	configuration()
	\|> put_in([:accounts, :max_pinned_statuses], Config.get([:instance, :max_pinned_statuses], 0))
	\|> put_in([:statuses, :characters_reserved_per_url], 0)
	\|> Map.merge(%{
	urls: %{
	streaming: Pleroma.Web.Endpoint.websocket_url(),
	status: Config.get([:instance, :status_page])
	},
	vapid: %{
	public_key: Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
	},
	- translation: %{enabled: Pleroma.Language.Translation.configured?()}
	+ translation: %{enabled: Pleroma.Language.Translation.configured?()},
	+ timelines_access: %{
	+ live_feeds: timelines_access(),
	+ hashtag_feeds: timelines_access(),
	+ # not implemented in Pleroma
	+ trending_link_feeds: %{
	+ local: "disabled",
	+ remote: "disabled"
	+ }
	+ }
	})
	end

	+ defp timelines_access do
	+ %{
	+ local: timeline_access(:local),
	+ remote: timeline_access(:federated)
	+ }
	+ end
	+
	+ defp timeline_access(kind) do
	+ if Config.restrict_unauthenticated_access?(:timelines, kind) do
	+ "authenticated"
	+ else
	+ "public"
	+ end
	+ end
	+
	defp pleroma_configuration(instance) do
	base_urls = %{}

	base_urls =
	if Config.get([:media_proxy, :enabled]) do
	Map.put(base_urls, :media_proxy, Config.get([:media_proxy, :base_url]))
	else
	base_urls
	end

	base_urls =
	case Config.get([Pleroma.Upload, :base_url]) do
	nil -> base_urls
	url -> Map.put(base_urls, :upload, url)
	end

	%{
	metadata: %{
	account_activation_required: Keyword.get(instance, :account_activation_required),
	features: features(),
	federation: federation(),
	fields_limits: fields_limits(),
	post_formats: Config.get([:instance, :allowed_post_formats]),
	birthday_required: Config.get([:instance, :birthday_required]),
	birthday_min_age: Config.get([:instance, :birthday_min_age]),
	translation: supported_languages(),
	base_urls: base_urls,
	markup: markup()
	},
	stats: %{mau: Pleroma.User.active_user_count()},
	vapid_public_key: Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
	}
	end

	defp pleroma_configuration2(instance) do
	configuration = pleroma_configuration(instance)

	configuration
	\|> Map.merge(%{
	metadata:
	configuration.metadata
	\|> Map.merge(%{
	avatar_upload_limit: Keyword.get(instance, :avatar_upload_limit),
	background_upload_limit: Keyword.get(instance, :background_upload_limit),
	banner_upload_limit: Keyword.get(instance, :banner_upload_limit),
	background_image:
	Pleroma.Web.Endpoint.url() <> Keyword.get(instance, :background_image),
	chat_limit: Keyword.get(instance, :chat_limit),
	description_limit: Keyword.get(instance, :description_limit),
	shout_limit: Config.get([:shout, :limit])
	})
	})
	end

	defp supported_languages do
	enabled = Pleroma.Language.Translation.configured?()

	source_languages =
	with true <- enabled,
	{:ok, languages} <- Pleroma.Language.Translation.supported_languages(:source) do
	languages
	else
	_ -> nil
	end

	target_languages =
	with true <- enabled,
	{:ok, languages} <- Pleroma.Language.Translation.supported_languages(:target) do
	languages
	else
	_ -> nil
	end

	%{
	source_languages: source_languages,
	target_languages: target_languages
	}
	end

	defp markup do
	%{
	allow_inline_images: Config.get([:markup, :allow_inline_images]),
	allow_headings: Config.get([:markup, :allow_headings]),
	allow_tables: Config.get([:markup, :allow_tables])
	}
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 4b5ac9c3b..c1c695419 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,861 +1,862 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	require Pleroma.Constants

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.PollView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.PleromaAPI.EmojiReactionController
	alias Pleroma.Web.RichMedia.Card

	import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1, visible_for_user?: 2]

	# This is a naive way to do this, just spawning a process per activity
	# to fetch the preview. However it should be fine considering
	# pagination is restricted to 40 activities at a time
	defp fetch_rich_media_for_activities(activities) do
	Enum.each(activities, fn activity ->
	Card.get_by_activity(activity)
	end)
	end

	# TODO: Add cached version.
	defp get_replied_to_activities([]), do: %{}

	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	defp get_quoted_activities([]), do: %{}

	defp get_quoted_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create"}} = activity ->
	object = Object.normalize(activity, fetch: false)
	object && object.data["quoteUrl"] != "" && object.data["quoteUrl"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity, fetch: false)
	if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	# DEPRECATED This field seems to be a left-over from the StatusNet era.
	# If your application uses `pleroma.conversation_id`: this field is deprecated.
	# It is currently stubbed instead by doing a CRC32 of the context, and
	# clearing the MSB to avoid overflow exceptions with signed integers on the
	# different clients using this field (Java/Kotlin code, mostly; see Husky.)
	# This should be removed in a future version of Pleroma. Pleroma-FE currently
	# depends on this field, as well.
	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context) do
	import Bitwise

	:erlang.crc32(context)
	\|> band(bnot(0x8000_0000))
	end

	defp get_context_id(_), do: nil

	# Check if the user reblogged this status
	defp reblogged?(activity, %User{ap_id: ap_id}) do
	with %Object{data: %{"announcements" => announcements}} when is_list(announcements) <-
	Object.normalize(activity, fetch: false) do
	ap_id in announcements
	else
	_ -> false
	end
	end

	# False if the user is logged out
	defp reblogged?(_activity, _user), do: false

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

	# To do: check AdminAPIControllerTest on the reasons behind nil activities in the list
	activities = Enum.filter(opts.activities, & &1)

	# Start prefetching rich media before doing anything else
	fetch_rich_media_for_activities(activities)
	replied_to_activities = get_replied_to_activities(activities)
	quoted_activities = get_quoted_activities(activities)

	parent_activities =
	activities
	\|> Enum.filter(&(&1.data["type"] == "Announce" && &1.data["object"]))
	\|> Enum.map(&Object.normalize(&1, fetch: false).data["id"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Activity.with_preloaded_bookmark(reading_user)
	\|> Activity.with_set_thread_muted_field(reading_user)
	\|> Repo.all()

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

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

	true ->
	# Note: unresolved users are filtered out
	actors =
	(activities ++ parent_activities)
	\|> Enum.map(&CommonAPI.get_user(&1.data["actor"], false))
	\|> Enum.filter(& &1)

	UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
	end

	opts =
	opts
	\|> Map.put(:replied_to_activities, replied_to_activities)
	\|> Map.put(:quoted_activities, quoted_activities)
	\|> Map.put(:parent_activities, parent_activities)
	\|> Map.put(:relationships, relationships_opt)

	safe_render_many(activities, StatusView, "show.json", opts)
	end

	def render(
	"show.json",
	%{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
	) do
	user = CommonAPI.get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])
	object = Object.normalize(activity, fetch: false)

	reblogged_parent_activity =
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(
	opts[:parent_activities],
	object.data["id"]
	)
	else
	Activity.create_by_object_ap_id(object.data["id"])
	\|> Activity.with_preloaded_bookmark(opts[:for])
	\|> Activity.with_set_thread_muted_field(opts[:for])
	\|> Repo.one()
	end

	reblog_rendering_opts = Map.put(opts, :activity, reblogged_parent_activity)
	reblogged = render("show.json", reblog_rendering_opts)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(reblogged_parent_activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: object.data["id"],
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: reblogged?(reblogged_parent_activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: false,
	pinned: pinned?,
	sensitive: false,
	spoiler_text: "",
	visibility: get_visibility(activity),
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: build_application(object.data["generator"]),
	language: get_language(object),
	emojis: [],
	pleroma: %{
	local: activity.local,
	pinned_at: pinned_at,
	bookmark_folder: bookmark_folder
	}
	}
	end

	def render("show.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	user = CommonAPI.get_user(activity.data["actor"])
	user_follower_address = user.follower_address

	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0

	hashtags = Object.hashtags(object)
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	tags = Object.tags(object)

	tag_mentions =
	tags
	\|> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
	\|> Enum.map(fn tag -> tag["href"] end)

	mentions =
	(object.data["to"] ++ tag_mentions)
	\|> Enum.uniq()
	\|> Enum.map(fn
	Pleroma.Constants.as_public() -> nil
	^user_follower_address -> nil
	ap_id -> User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmark = Activity.get_bookmark(activity, opts[:for])

	bookmark_folder =
	if bookmark != nil do
	bookmark.folder_id
	else
	nil
	end

	client_posted_this_activity = opts[:for] && user.id == opts[:for].id

	expires_at =
	with true <- client_posted_this_activity,
	%Oban.Job{scheduled_at: scheduled_at} <-
	Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id) do
	scheduled_at
	else
	_ -> nil
	end

	thread_muted? =
	cond do
	is_nil(opts[:for]) -> false
	is_boolean(activity.thread_muted?) -> activity.thread_muted?
	true -> CommonAPI.thread_muted?(activity, opts[:for])
	end

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["published"])

	edited_at =
	with %{"updated" => updated} <- object.data,
	date <- Utils.to_masto_date(updated),
	true <- date != "" do
	date
	else
	_ ->
	nil
	end

	reply_to = get_reply_to(activity, opts)
	reply_to_user = reply_to && CommonAPI.get_user(reply_to.data["actor"])

	history_len =
	1 +
	(Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> length())

	# See render("history.json", ...) for more details
	# Here the implicit index of the current content is 0
	chrono_order = history_len - 1

	quote_activity = get_quote(activity, opts)

	quote_id =
	case quote_activity do
	%Activity{id: id} -> id
	_ -> nil
	end

	quote_post =
	if visible_for_user?(quote_activity, opts[:for]) and opts[:show_quote] != false do
	quote_rendering_opts = Map.merge(opts, %{activity: quote_activity, show_quote: false})
	render("show.json", quote_rendering_opts)
	else
	nil
	end

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	content_plaintext =
	content
	\|> Activity.HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	card =
	case Card.get_by_activity(activity) do
	%Card{} = result -> render("card.json", result)
	_ -> nil
	end

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	object.data["url"] \|\| object.data["external_url"] \|\| object.data["id"]
	end

	direct_conversation_id =
	with {_, nil} <- {:direct_conversation_id, opts[:direct_conversation_id]},
	{_, true} <- {:include_id, opts[:with_direct_conversation_id]},
	{_, %User{} = for_user} <- {:for_user, opts[:for]} do
	Activity.direct_conversation_id(activity, for_user)
	else
	{:direct_conversation_id, participation_id} when is_integer(participation_id) ->
	participation_id

	_e ->
	nil
	end

	emoji_reactions =
	object
	\|> Object.get_emoji_reactions()
	\|> EmojiReactionController.filter_allowed_users(
	opts[:for],
	Map.get(opts, :with_muted, false)
	)
	\|> Stream.map(fn {emoji, users, url} ->
	build_emoji_map(emoji, users, url, opts[:for])
	end)
	\|> Enum.to_list()

	# Status muted state (would do 1 request per status unless user mutes are preloaded)
	muted =
	thread_muted? \|\|
	UserRelationship.exists?(
	get_in(opts, [:relationships, :user_relationships]),
	:mute,
	opts[:for],
	user,
	fn for_user, user -> User.mutes?(for_user, user) end
	)

	{pinned?, pinned_at} = pin_data(object, user)

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	content: content_html,
	text: opts[:with_source] && get_source_text(object.data["source"]),
	created_at: created_at,
	edited_at: edited_at,
	reblogs_count: announcement_count,
	replies_count: object.data["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: reblogged?(activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmark),
	muted: muted,
	pinned: pinned?,
	sensitive: sensitive,
	spoiler_text: summary,
	visibility: get_visibility(object),
	media_attachments: attachments,
	poll: render(PollView, "show.json", object: object, for: opts[:for]),
	mentions: mentions,
	tags: build_tags(tags),
	application: build_application(object.data["generator"]),
	language: get_language(object),
	emojis: build_emojis(object.data["emoji"]),
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	context: object.data["context"],
	in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
	quote: quote_post,
	quote_id: quote_id,
	quote_url: object.data["quoteUrl"],
	quote_visible: visible_for_user?(quote_activity, opts[:for]),
	content: %{"text/plain" => content_plaintext},
	spoiler_text: %{"text/plain" => summary},
	expires_at: expires_at,
	direct_conversation_id: direct_conversation_id,
	thread_muted: thread_muted?,
	emoji_reactions: emoji_reactions,
	parent_visible: visible_for_user?(reply_to, opts[:for]),
	pinned_at: pinned_at,
	quotes_count: object.data["quotesCount"] \|\| 0,
	bookmark_folder: bookmark_folder,
	list_id: get_list_id(object, client_posted_this_activity)
	}
	}
	end

	def render("show.json", _) do
	nil
	end

	def render("history.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity, fetch: false)

	hashtags = Object.hashtags(object)

	user = CommonAPI.get_user(activity.data["actor"])

	past_history =
	Object.Updater.history_for(object.data)
	\|> Map.get("orderedItems")
	\|> Enum.map(&Map.put(&1, "id", object.data["id"]))
	\|> Enum.map(&%Object{data: &1, id: object.id})

	history =
	[object \| past_history]
	# Mastodon expects the original to be at the first
	\|> Enum.reverse()
	\|> Enum.with_index()
	\|> Enum.map(fn {object, chrono_order} ->
	%{
	# The history is prepended every time there is a new edit.
	# In chrono_order, the oldest item is always at 0, and so on.
	# The chrono_order is an invariant kept between edits.
	chrono_order: chrono_order,
	object: object
	}
	end)

	individual_opts =
	opts
	\|> Map.put(:as, :item)
	\|> Map.put(:user, user)
	\|> Map.put(:hashtags, hashtags)

	render_many(history, StatusView, "history_item.json", individual_opts)
	end

	def render(
	"history_item.json",
	%{
	activity: activity,
	user: user,
	item: %{object: object, chrono_order: chrono_order},
	hashtags: hashtags
	} = opts
	) do
	sensitive = object.data["sensitive"] \|\| Enum.member?(hashtags, "nsfw")

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["updated"] \|\| object.data["published"])

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> Activity.HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content:#{chrono_order}"
	)

	summary = object.data["summary"] \|\| ""

	%{
	account:
	AccountView.render("show.json", %{
	user: user,
	for: opts[:for]
	}),
	content: content_html,
	sensitive: sensitive,
	spoiler_text: summary,
	created_at: created_at,
	media_attachments: attachments,
	emojis: build_emojis(object.data["emoji"]),
	poll: render(PollView, "show.json", object: object, for: opts[:for])
	}
	end

	def render("source.json", %{activity: %{data: %{"object" => _object}} = activity} = _opts) do
	object = Object.normalize(activity, fetch: false)

	%{
	id: activity.id,
	text: get_source_text(Map.get(object.data, "source", "")),
	spoiler_text: Map.get(object.data, "summary", ""),
	content_type: get_source_content_type(object.data["source"])
	}
	end

	def render("card.json", %Card{fields: rich_media}) do
	page_url_data = URI.parse(rich_media["url"])

	page_url = page_url_data \|> to_string

	image_url = proxied_url(rich_media["image"], page_url_data)
	audio_url = proxied_url(rich_media["audio"], page_url_data)
	video_url = proxied_url(rich_media["video"], page_url_data)

	%{
	type: "link",
	provider_name: page_url_data.host,
	provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url,
	image_description: rich_media["image:alt"] \|\| "",
	title: rich_media["title"] \|\| "",
	description: rich_media["description"] \|\| "",
	pleroma: %{
	opengraph:
	rich_media
	\|> Maps.put_if_present("image", image_url)
	\|> Maps.put_if_present("audio", audio_url)
	\|> Maps.put_if_present("video", video_url)
	}
	}
	end

	def render("card.json", _), do: nil

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	- href = attachment_url["href"] \|> MediaProxy.url()
	+ href_remote = attachment_url["href"]
	+ href = href_remote \|> MediaProxy.url()
	href_preview = attachment_url["href"] \|> MediaProxy.preview_url()
	meta = render("attachment_meta.json", %{attachment: attachment})

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	attachment_id =
	with {_, ap_id} when is_binary(ap_id) <- {:ap_id, attachment["id"]},
	{_, %Object{data: _object_data, id: object_id}} <-
	{:object, Object.get_by_ap_id(ap_id)} do
	to_string(object_id)
	else
	_ ->
	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)
	to_string(attachment["id"] \|\| hash_id)
	end

	description =
	if attachment["summary"] do
	HTML.strip_tags(attachment["summary"])
	else
	attachment["name"]
	end

	name = if attachment["summary"], do: attachment["name"]

	pleroma =
	%{mime_type: media_type}
	\|> Maps.put_if_present(:name, name)

	%{
	id: attachment_id,
	url: href,
	- remote_url: href,
	+ remote_url: href_remote,
	preview_url: href_preview,
	text_url: href,
	type: type,
	description: description,
	pleroma: pleroma,
	blurhash: attachment["blurhash"]
	}
	\|> Maps.put_if_present(:meta, meta)
	end

	def render("attachment_meta.json", %{
	attachment: %{"url" => [%{"width" => width, "height" => height} \| _]}
	})
	when is_integer(width) and is_integer(height) do
	%{
	original: %{
	width: width,
	height: height,
	aspect: width / height
	}
	}
	end

	def render("attachment_meta.json", _), do: nil

	def render("context.json", %{activity: activity, activities: activities, user: user}) do
	%{ancestors: ancestors, descendants: descendants} =
	activities
	\|> Enum.reverse()
	\|> Enum.group_by(fn %{id: id} -> if id < activity.id, do: :ancestors, else: :descendants end)
	\|> Map.put_new(:ancestors, [])
	\|> Map.put_new(:descendants, [])

	%{
	ancestors: render("index.json", for: user, activities: ancestors, as: :activity),
	descendants: render("index.json", for: user, activities: descendants, as: :activity)
	}
	end

	def render("translation.json", %{
	content: content,
	detected_source_language: detected_source_language,
	provider: provider
	}) do
	%{content: content, detected_source_language: detected_source_language, provider: provider}
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- replied_to_activities[object.data["inReplyTo"]] do
	# If user didn't participate in the thread
	Activity.get_in_reply_to_activity(activity)
	end
	end

	def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
	Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
	else
	nil
	end
	end

	def get_quote(activity, %{quoted_activities: quoted_activities}) do
	object = Object.normalize(activity, fetch: false)

	with nil <- quoted_activities[object.data["quoteUrl"]] do
	# For when a quote post is inside an Announce
	Activity.get_create_by_object_ap_id_with_object(object.data["quoteUrl"])
	end
	end

	def get_quote(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity, fetch: false)

	if object.data["quoteUrl"] && object.data["quoteUrl"] != "" do
	Activity.get_create_by_object_ap_id(object.data["quoteUrl"])
	else
	nil
	end
	end

	def render_content(%{data: %{"name" => name}} = object) when not is_nil(name) and name != "" do
	url = object.data["url"] \|\| object.data["id"]

	"<p><a href=\"#{url}\">#{name}</a></p>#{object.data["content"]}"
	end

	def render_content(object), do: object.data["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags
	\|> Enum.filter(&is_binary/1)
	\|> Enum.map(&%{name: &1, url: "#{Pleroma.Web.Endpoint.url()}/tag/#{URI.encode(&1)}"})
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

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

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pin_data(%Object{data: %{"id" => object_id}}, %User{pinned_objects: pinned_objects}) do
	if pinned_at = pinned_objects[object_id] do
	{true, Utils.to_masto_date(pinned_at)}
	else
	{false, nil}
	end
	end

	defp build_emoji_map(emoji, users, url, current_user) do
	%{
	name: Pleroma.Web.PleromaAPI.EmojiReactionView.emoji_name(emoji, url),
	count: length(users),
	url: MediaProxy.url(url),
	me: !!(current_user && current_user.ap_id in users),
	account_ids: Enum.map(users, fn user -> User.get_cached_by_ap_id(user).id end)
	}
	end

	@spec build_application(map() \| nil) :: map() \| nil
	defp build_application(%{"type" => _type, "name" => name, "url" => url}),
	do: %{name: name, website: url}

	defp build_application(_), do: nil

	@spec build_image_url(URI.t(), URI.t()) :: String.t()
	defp build_image_url(%URI{} = image_url_data, %URI{} = page_url_data) do
	URI.merge(page_url_data, image_url_data) \|> to_string
	end

	defp get_source_text(%{"content" => content} = _source) do
	content
	end

	defp get_source_text(source) when is_binary(source) do
	source
	end

	defp get_source_text(_) do
	""
	end

	defp get_source_content_type(%{"mediaType" => type} = _source) do
	type
	end

	defp get_source_content_type(_source) do
	Utils.get_content_type(nil)
	end

	defp get_language(%{data: %{"language" => "und"}}), do: nil

	defp get_language(object), do: object.data["language"]

	defp proxied_url(url, page_url_data) do
	if is_binary(url) do
	build_image_url(URI.parse(url), page_url_data) \|> MediaProxy.url()
	else
	nil
	end
	end

	defp get_list_id(object, client_posted_this_activity) do
	with true <- client_posted_this_activity,
	%{data: %{"listMessage" => list_ap_id}} when is_binary(list_ap_id) <- object,
	%{id: list_id} <- Pleroma.List.get_by_ap_id(list_ap_id) do
	list_id
	else
	_ -> nil
	end
	end
	end
	diff --git a/lib/pleroma/web/pleroma_api/controllers/account_controller.ex b/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
	index 591391b60..0b8e0b7ad 100644
	--- a/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
	+++ b/lib/pleroma/web/pleroma_api/controllers/account_controller.ex
	@@ -1,159 +1,136 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.Plugs.RateLimiter

	require Pleroma.Constants

	plug(
	Majic.Plug,
	[pool: Pleroma.MajicPool] when action in [:update_avatar, :update_background, :update_banner]
	)

	plug(
	OpenApiSpex.Plug.PutApiSpec,
	[module: Pleroma.Web.ApiSpec] when action == :confirmation_resend
	)

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	plug(:skip_auth when action == :confirmation_resend)

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

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

	- plug(
	- OAuthScopesPlug,
	- %{fallback: :proceed_unauthenticated, scopes: ["read:accounts"]}
	- when action == :endorsements
	- )
	-
	plug(
	OAuthScopesPlug,
	%{scopes: ["read:accounts"]} when action == :birthdays
	)

	plug(RateLimiter, [name: :account_confirmation_resend] when action == :confirmation_resend)

	plug(
	:assign_account_by_id
	- when action in [:favourites, :endorsements, :subscribe, :unsubscribe]
	+ when action in [:favourites, :subscribe, :unsubscribe]
	)

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

	@doc "POST /api/v1/pleroma/accounts/confirmation_resend"
	def confirmation_resend(conn, params) do
	nickname_or_email = params[:email] \|\| params[:nickname]

	with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
	{:ok, _} <- User.maybe_send_confirmation_email(user) do
	json_response(conn, :no_content, "")
	end
	end

	@doc "GET /api/v1/pleroma/accounts/:id/favourites"
	def favourites(%{assigns: %{account: %{hide_favorites: true}}} = conn, _params) do
	render_error(conn, :forbidden, "Can't get favorites")
	end

	def favourites(%{assigns: %{user: for_user, account: user}} = conn, params) do
	params =
	params
	\|> Map.put(:type, "Create")
	\|> Map.put(:favorited_by, user.ap_id)
	\|> Map.put(:blocking_user, for_user)

	recipients =
	if for_user do
	[Pleroma.Constants.as_public()] ++ [for_user.ap_id \| User.following(for_user)]
	else
	[Pleroma.Constants.as_public()]
	end

	activities =
	recipients
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(activities)
	\|> put_view(StatusView)
	\|> render("index.json",
	activities: activities,
	for: for_user,
	as: :activity
	)
	end

	- @doc "GET /api/v1/pleroma/accounts/:id/endorsements"
	- def endorsements(%{assigns: %{user: for_user, account: user}} = conn, params) do
	- users =
	- user
	- \|> User.endorsed_users_relation(_restrict_deactivated = true)
	- \|> Pleroma.Repo.all()
	-
	- conn
	- \|> render("index.json",
	- for: for_user,
	- users: users,
	- as: :user,
	- embed_relationships: embed_relationships?(params)
	- )
	- end
	-
	@doc "POST /api/v1/pleroma/accounts/:id/subscribe"
	def subscribe(%{assigns: %{user: user, account: subscription_target}} = conn, _params) do
	with {:ok, _subscription} <- User.subscribe(user, subscription_target) do
	render(conn, "relationship.json", user: user, target: subscription_target)
	else
	{:error, message} -> json_response(conn, :forbidden, %{error: message})
	end
	end

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

	@doc "GET /api/v1/pleroma/birthdays"
	def birthdays(%{assigns: %{user: %User{} = user}} = conn, %{day: day, month: month} = _params) do
	birthdays =
	User.get_friends_birthdays_query(user, day, month)
	\|> Pleroma.Repo.all()

	conn
	\|> render("index.json",
	for: user,
	users: birthdays,
	as: :user
	)
	end
	end
	diff --git a/lib/pleroma/web/push/subscription.ex b/lib/pleroma/web/push/subscription.ex
	index 6fc45bd61..c6fe69e84 100644
	--- a/lib/pleroma/web/push/subscription.ex
	+++ b/lib/pleroma/web/push/subscription.ex
	@@ -1,102 +1,102 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.Subscription do
	use Ecto.Schema

	import Ecto.Changeset

	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.Push.Subscription

	@type t :: %__MODULE__{}

	schema "push_subscriptions" do
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	belongs_to(:token, Token)
	field(:endpoint, :string)
	field(:key_p256dh, :string)
	field(:key_auth, :string)
	field(:data, :map, default: %{})

	timestamps()
	end

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	- @supported_alert_types ~w[follow favourite mention reblog poll pleroma:chat_mention pleroma:emoji_reaction]a
	+ @supported_alert_types ~w[follow favourite mention status reblog poll pleroma:chat_mention pleroma:emoji_reaction]a

	defp alerts(%{data: %{alerts: alerts}}) do
	alerts = Map.take(alerts, @supported_alert_types)
	%{"alerts" => alerts}
	end

	def enabled?(subscription, "follow_request") do
	enabled?(subscription, "follow")
	end

	def enabled?(subscription, alert_type) do
	get_in(subscription.data, ["alerts", alert_type])
	end

	def create(
	%User{} = user,
	%Token{} = token,
	%{
	subscription: %{
	endpoint: endpoint,
	keys: %{auth: key_auth, p256dh: key_p256dh}
	}
	} = params
	) do
	Repo.insert(%Subscription{
	user_id: user.id,
	token_id: token.id,
	endpoint: endpoint,
	key_auth: ensure_base64_urlsafe(key_auth),
	key_p256dh: ensure_base64_urlsafe(key_p256dh),
	data: alerts(params)
	})
	end

	@doc "Gets subsciption by user & token"
	@spec get(User.t(), Token.t()) :: {:ok, t()} \| {:error, :not_found}
	def get(%User{id: user_id}, %Token{id: token_id}) do
	case Repo.get_by(Subscription, user_id: user_id, token_id: token_id) do
	nil -> {:error, :not_found}
	subscription -> {:ok, subscription}
	end
	end

	def update(user, token, params) do
	with {:ok, subscription} <- get(user, token) do
	subscription
	\|> change(data: alerts(params))
	\|> Repo.update()
	end
	end

	def delete(user, token) do
	with {:ok, subscription} <- get(user, token),
	do: Repo.delete(subscription)
	end

	def delete_if_exists(user, token) do
	case get(user, token) do
	{:error, _} -> {:ok, nil}
	{:ok, sub} -> Repo.delete(sub)
	end
	end

	# Some webpush clients (e.g. iOS Toot!) use an non urlsafe base64 as an encoding for the key.
	# However, the web push rfs specify to use base64 urlsafe, and the `web_push_encryption` library
	# we use requires the key to be properly encoded. So we just convert base64 to urlsafe base64.
	defp ensure_base64_urlsafe(string) do
	string
	\|> String.replace("+", "-")
	\|> String.replace("/", "_")
	\|> String.replace("=", "")
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index cd9cfd3ed..a8636cfba 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,1073 +1,1080 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router
	import Phoenix.LiveDashboard.Router

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

	pipeline :accepts_html_xml do
	plug(:accepts, ["html", "xml", "rss", "atom"])
	end

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

	pipeline :accepts_html_xml_json do
	plug(:accepts, ["html", "xml", "rss", "atom", "activity+json", "json"])
	end

	pipeline :accepts_xml_rss_atom do
	plug(:accepts, ["xml", "rss", "atom"])
	end

	pipeline :browser do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Web.Plugs.LoggerMetadataUser)
	end

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

	# Note: expects _user_ authentication (user-unbound app-bound tokens don't qualify)
	pipeline :expect_user_authentication do
	plug(Pleroma.Web.Plugs.ExpectAuthenticatedCheckPlug)
	end

	# Note: expects public instance or _user_ authentication (user-unbound tokens don't qualify)
	pipeline :expect_public_instance_or_user_authentication do
	plug(Pleroma.Web.Plugs.ExpectPublicOrAuthenticatedCheckPlug)
	end

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

	pipeline :after_auth do
	plug(Pleroma.Web.Plugs.UserEnabledPlug)
	plug(Pleroma.Web.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Web.Plugs.EnsureUserTokenAssignsPlug)
	plug(Pleroma.Web.Plugs.UserTrackingPlug)
	end

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

	pipeline :no_auth_or_privacy_expectations_api do
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Web.Plugs.IdempotencyPlug)
	plug(Pleroma.Web.Plugs.LoggerMetadataUser)
	end

	# Pipeline for app-related endpoints (no user auth checks — app-bound tokens must be supported)
	pipeline :app_api do
	plug(:no_auth_or_privacy_expectations_api)
	end

	pipeline :api do
	plug(:expect_public_instance_or_user_authentication)
	plug(:no_auth_or_privacy_expectations_api)
	plug(Pleroma.Web.Plugs.LoggerMetadataUser)
	end

	pipeline :authenticated_api do
	plug(:expect_user_authentication)
	plug(:no_auth_or_privacy_expectations_api)
	plug(Pleroma.Web.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Web.Plugs.LoggerMetadataUser)
	end

	pipeline :admin_api do
	plug(:expect_user_authentication)
	plug(:base_api)
	plug(Pleroma.Web.Plugs.AdminSecretAuthenticationPlug)
	plug(:after_auth)
	plug(Pleroma.Web.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Web.Plugs.UserIsStaffPlug)
	plug(Pleroma.Web.Plugs.IdempotencyPlug)
	plug(Pleroma.Web.Plugs.LoggerMetadataUser)
	end

	pipeline :require_admin do
	plug(Pleroma.Web.Plugs.UserIsAdminPlug)
	end

	pipeline :require_privileged_role_users_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_delete)
	end

	pipeline :require_privileged_role_users_manage_credentials do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_credentials)
	end

	pipeline :require_privileged_role_messages_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :messages_read)
	end

	pipeline :require_privileged_role_users_manage_tags do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_tags)
	end

	pipeline :require_privileged_role_users_manage_activation_state do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_activation_state)
	end

	pipeline :require_privileged_role_users_manage_invites do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_manage_invites)
	end

	pipeline :require_privileged_role_reports_manage_reports do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :reports_manage_reports)
	end

	pipeline :require_privileged_role_users_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :users_read)
	end

	pipeline :require_privileged_role_messages_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :messages_delete)
	end

	pipeline :require_privileged_role_emoji_manage_emoji do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :emoji_manage_emoji)
	end

	pipeline :require_privileged_role_instances_delete do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :instances_delete)
	end

	pipeline :require_privileged_role_moderation_log_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :moderation_log_read)
	end

	pipeline :require_privileged_role_statistics_read do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :statistics_read)
	end

	pipeline :require_privileged_role_announcements_manage_announcements do
	plug(:admin_api)
	plug(Pleroma.Web.Plugs.EnsurePrivilegedPlug, :announcements_manage_announcements)
	end

	pipeline :pleroma_html do
	plug(:browser)
	plug(:authenticate)
	plug(Pleroma.Web.Plugs.EnsureUserTokenAssignsPlug)
	plug(Pleroma.Web.Plugs.LoggerMetadataUser)
	end

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

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

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

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

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

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

	pipeline :inbox_guard do
	plug(Pleroma.Web.Plugs.InboxGuardPlug)
	end

	pipeline :static_fe do
	plug(Pleroma.Web.Plugs.StaticFEPlug)
	end

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

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

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

	get("/federation_status", InstancesController, :show)
	end

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

	# AdminAPI: only admins can perform these actions
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through([:admin_api, :require_admin])

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

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

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

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

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

	post("/users/follow", UserController, :follow)
	post("/users/unfollow", UserController, :unfollow)
	post("/users", UserController, :create)

	patch("/users/suggest", UserController, :suggest)
	patch("/users/unsuggest", UserController, :unsuggest)

	get("/relay", RelayController, :index)
	post("/relay", RelayController, :follow)
	delete("/relay", RelayController, :unfollow)

	get("/instance_document/:name", InstanceDocumentController, :show)
	patch("/instance_document/:name", InstanceDocumentController, :update)
	delete("/instance_document/:name", InstanceDocumentController, :delete)

	get("/config", ConfigController, :show)
	post("/config", ConfigController, :update)
	get("/config/descriptions", ConfigController, :descriptions)
	get("/need_reboot", AdminAPIController, :need_reboot)
	get("/restart", AdminAPIController, :restart)

	get("/oauth_app", OAuthAppController, :index)
	post("/oauth_app", OAuthAppController, :create)
	patch("/oauth_app/:id", OAuthAppController, :update)
	delete("/oauth_app/:id", OAuthAppController, :delete)

	get("/media_proxy_caches", MediaProxyCacheController, :index)
	post("/media_proxy_caches/delete", MediaProxyCacheController, :delete)
	post("/media_proxy_caches/purge", MediaProxyCacheController, :purge)

	get("/frontends", FrontendController, :index)
	post("/frontends/install", FrontendController, :install)

	post("/backups", AdminAPIController, :create_backup)

	get("/rules", RuleController, :index)
	post("/rules", RuleController, :create)
	patch("/rules/:id", RuleController, :update)
	delete("/rules/:id", RuleController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_announcements_manage_announcements)

	get("/announcements", AnnouncementController, :index)
	post("/announcements", AnnouncementController, :create)
	get("/announcements/:id", AnnouncementController, :show)
	patch("/announcements/:id", AnnouncementController, :change)
	delete("/announcements/:id", AnnouncementController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_delete)

	delete("/users", UserController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_credentials)

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)
	get("/users/:nickname/credentials", AdminAPIController, :show_user_credentials)
	patch("/users/:nickname/credentials", AdminAPIController, :update_user_credentials)
	put("/users/disable_mfa", AdminAPIController, :disable_mfa)
	patch("/users/force_password_reset", AdminAPIController, :force_password_reset)
	patch("/users/confirm_email", AdminAPIController, :confirm_email)
	patch("/users/resend_confirmation_email", AdminAPIController, :resend_confirmation_email)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_messages_read)

	get("/users/:nickname/statuses", AdminAPIController, :list_user_statuses)
	get("/users/:nickname/chats", AdminAPIController, :list_user_chats)

	get("/statuses", StatusController, :index)

	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)

	get("/instances/:instance/statuses", InstanceController, :list_statuses)

	get("/statuses/:id", StatusController, :show)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_tags)

	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_activation_state)

	patch("/users/:nickname/toggle_activation", UserController, :toggle_activation)
	patch("/users/activate", UserController, :activate)
	patch("/users/deactivate", UserController, :deactivate)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_manage_invites)

	patch("/users/approve", UserController, :approve)
	post("/users/invite_token", InviteController, :create)
	get("/users/invites", InviteController, :index)
	post("/users/revoke_invite", InviteController, :revoke)
	post("/users/email_invite", InviteController, :email)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_reports_manage_reports)

	get("/reports", ReportController, :index)
	get("/reports/:id", ReportController, :show)
	patch("/reports", ReportController, :update)
	post("/reports/:id/notes", ReportController, :notes_create)
	delete("/reports/:report_id/notes/:id", ReportController, :notes_delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_users_read)

	get("/users", UserController, :index)
	get("/users/:nickname", UserController, :show)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_messages_delete)

	put("/statuses/:id", StatusController, :update)
	delete("/statuses/:id", StatusController, :delete)

	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_emoji_manage_emoji)

	post("/reload_emoji", AdminAPIController, :reload_emoji)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_instances_delete)

	delete("/instances/:instance", InstanceController, :delete)
	end

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_moderation_log_read)

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

	# AdminAPI: admins and mods (staff) can perform these actions (if privileged by role)
	scope "/api/v1/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:require_privileged_role_statistics_read)

	get("/stats", AdminAPIController, :stats)
	end

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

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

	scope "/pack" do
	pipe_through(:api)

	get("/", EmojiPackController, :show)
	end

	# Modifying packs
	scope "/packs" do
	pipe_through(:require_privileged_role_emoji_manage_emoji)

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

	post("/files", EmojiFileController, :create)
	patch("/files", EmojiFileController, :update)
	delete("/files", EmojiFileController, :delete)
	end

	# Pack info / downloading
	scope "/packs" do
	pipe_through(:api)

	get("/", EmojiPackController, :index)
	get("/archive", EmojiPackController, :archive)
	end
	end

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

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

	get("/authorize_interaction", RemoteFollowController, :authorize_interaction)
	end

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

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

	put("/aliases", UtilController, :add_alias)
	get("/aliases", UtilController, :list_aliases)
	delete("/aliases", UtilController, :delete_alias)
	end

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

	post("/mutes_import", UserImportController, :mutes)
	post("/blocks_import", UserImportController, :blocks)
	post("/follow_import", UserImportController, :follow)

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

	scope "/oauth", Pleroma.Web.OAuth do
	# Note: use /api/v1/accounts/verify_credentials for userinfo of signed-in user

	get("/registration_details", OAuthController, :registration_details)

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

	scope [] do
	pipe_through(:oauth)

	get("/authorize", OAuthController, :authorize)
	post("/authorize", OAuthController, :create_authorization)
	end

	scope [] do
	pipe_through(:fetch_session)

	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	post("/mfa/challenge", MFAController, :challenge)
	end

	scope [] do
	pipe_through(:browser)

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

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

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

	scope "/api/v0/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:authenticated_api)
	get("/reports", ReportController, :index)
	get("/reports/:id", ReportController, :show)
	end

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

	post("/chats/by-account-id/:id", ChatController, :create)
	get("/chats", ChatController, :index)
	get("/chats/:id", ChatController, :show)
	get("/chats/:id/messages", ChatController, :messages)
	post("/chats/:id/messages", ChatController, :post_chat_message)
	delete("/chats/:id/messages/:message_id", ChatController, :delete_message)
	post("/chats/:id/read", ChatController, :mark_as_read)
	post("/chats/:id/messages/:message_id/read", ChatController, :mark_message_as_read)

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

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

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

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

	get("/backups", BackupController, :index)
	post("/backups", BackupController, :create)

	get("/bookmark_folders", BookmarkFolderController, :index)
	post("/bookmark_folders", BookmarkFolderController, :create)
	patch("/bookmark_folders/:id", BookmarkFolderController, :update)
	delete("/bookmark_folders/:id", BookmarkFolderController, :delete)
	end

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

	get("/statuses/:id/quotes", StatusController, :quotes)
	end

	scope [] do
	pipe_through(:authenticated_api)

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

	get("/birthdays", AccountController, :birthdays)
	end

	scope [] do
	pipe_through(:authenticated_api)

	get("/settings/:app", SettingsController, :show)
	patch("/settings/:app", SettingsController, :update)
	end

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

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

	+ scope "/api/v1/pleroma", Pleroma.Web.MastodonAPI do
	+ pipe_through(:api)
	+ get("/accounts/:id/endorsements", AccountController, :endorsements)
	+ end
	+
	scope "/api/v2/pleroma", Pleroma.Web.PleromaAPI do
	scope [] do
	pipe_through(:authenticated_api)
	get("/chats", ChatController, :index2)
	end
	end

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

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

	get("/accounts/relationships", AccountController, :relationships)
	get("/accounts/familiar_followers", AccountController, :familiar_followers)
	get("/accounts/:id/lists", AccountController, :lists)
	- get("/endorsements", AccountController, :endorsements)
	+ get("/endorsements", AccountController, :own_endorsements)
	get("/blocks", AccountController, :blocks)
	get("/mutes", AccountController, :mutes)

	post("/follows", AccountController, :follow_by_uri)
	post("/accounts/:id/follow", AccountController, :follow)
	post("/accounts/:id/unfollow", AccountController, :unfollow)
	post("/accounts/:id/block", AccountController, :block)
	post("/accounts/:id/unblock", AccountController, :unblock)
	post("/accounts/:id/mute", AccountController, :mute)
	post("/accounts/:id/unmute", AccountController, :unmute)
	post("/accounts/:id/note", AccountController, :note)
	post("/accounts/:id/pin", AccountController, :endorse)
	post("/accounts/:id/unpin", AccountController, :unendorse)
	+ post("/accounts/:id/endorse", AccountController, :endorse)
	+ post("/accounts/:id/unendorse", AccountController, :unendorse)
	post("/accounts/:id/remove_from_followers", AccountController, :remove_from_followers)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	get("/suggestions", SuggestionController, :index)
	delete("/suggestions/:account_id", SuggestionController, :dismiss)

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

	get("/announcements", AnnouncementController, :index)
	post("/announcements/:id/dismiss", AnnouncementController, :mark_read)

	get("/tags/:id", TagController, :show)
	post("/tags/:id/follow", TagController, :follow)
	post("/tags/:id/unfollow", TagController, :unfollow)
	get("/followed_tags", TagController, :show_followed)
	end

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

	post("/apps", AppController, :create)
	get("/apps/verify_credentials", AppController, :verify_credentials)
	end

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

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

	get("/accounts/lookup", AccountController, :lookup)

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

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

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

	get("/statuses", StatusController, :index)
	get("/statuses/:id", StatusController, :show)
	get("/statuses/:id/context", StatusController, :context)
	get("/statuses/:id/favourited_by", StatusController, :favourited_by)
	get("/statuses/:id/reblogged_by", StatusController, :reblogged_by)
	get("/statuses/:id/history", StatusController, :show_history)
	get("/statuses/:id/source", StatusController, :show_source)

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

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

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

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

	get("/directory", DirectoryController, :index)
	end

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

	get("/search", SearchController, :search2)

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

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

	get("/instance", InstanceController, :show2)
	end

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

	get("/pleroma/frontend_configurations", TwitterAPI.UtilController, :frontend_configurations)
	end

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

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

	scope "/api" do
	pipe_through(:base_api)

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

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

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

	scope "/", Pleroma.Web do
	# Note: html format is supported only if static FE is enabled
	# Note: http signature is only considered for json requests (no auth for non-json requests)
	pipe_through([:accepts_html_json, :http_signature, :static_fe])

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

	# Mastodon compatibility routes
	get("/users/:nickname/statuses/:id", OStatus.OStatusController, :object)
	get("/users/:nickname/statuses/:id/activity", OStatus.OStatusController, :activity)
	end

	scope "/", Pleroma.Web do
	# Note: html format is supported only if static FE is enabled
	# Note: http signature is only considered for json requests (no auth for non-json requests)
	pipe_through([:accepts_html_xml_json, :http_signature, :static_fe])

	# Note: returns user _profile_ for json requests, redirects to user _feed_ for non-json ones
	get("/users/:nickname", Feed.UserController, :feed_redirect, as: :user_feed)
	end

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

	get("/users/:nickname/feed", Feed.UserController, :feed, as: :user_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through(:accepts_html)
	get("/notice/:id/embed_player", OStatus.OStatusController, :notice_player)
	end

	scope "/", Pleroma.Web do
	pipe_through(:accepts_xml_rss_atom)
	get("/tags/:tag", Feed.TagController, :feed, as: :tag_feed)
	end

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

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

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

	# Client to Server (C2S) AP interactions
	pipeline :activitypub_client do
	plug(:ap_service_actor)
	plug(Pleroma.Web.Plugs.APClientApiEnabledPlug)
	plug(:fetch_session)
	plug(:authenticate)
	plug(:after_auth)
	end

	# AP interactions used by both S2S and C2S
	pipeline :activitypub_server_or_client do
	plug(:ap_service_actor)
	plug(:fetch_session)
	plug(:authenticate)
	plug(Pleroma.Web.Plugs.APClientApiEnabledPlug, allow_server: true)
	plug(:after_auth)
	plug(:http_signature)
	end

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

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

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

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

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

	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	get("/users/:nickname/collections/featured", ActivityPubController, :pinned)
	end

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

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

	get("/", ActivityPubController, :relay)

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

	get("/following", ActivityPubController, :relay_following)
	get("/followers", ActivityPubController, :relay_followers)
	end

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

	get("/", ActivityPubController, :internal_fetch)
	post("/inbox", ActivityPubController, :inbox)
	end

	scope "/.well-known", Pleroma.Web do
	pipe_through(:well_known)

	get("/host-meta", WebFinger.WebFingerController, :host_meta)
	get("/webfinger", WebFinger.WebFingerController, :webfinger)
	get("/nodeinfo", Nodeinfo.NodeinfoController, :schemas)
	end

	scope "/nodeinfo", Pleroma.Web do
	get("/:version", Nodeinfo.NodeinfoController, :nodeinfo)
	end

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

	get("/manifest.json", ManifestController, :show)
	end

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

	post("/auth/password", TwitterAPI.PasswordController, :request)
	end

	scope "/proxy/", Pleroma.Web do
	get("/preview/:sig/:url", MediaProxy.MediaProxyController, :preview)
	get("/preview/:sig/:url/:filename", MediaProxy.MediaProxyController, :preview)
	get("/:sig/:url", MediaProxy.MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxy.MediaProxyController, :remote)
	end

	if Pleroma.Config.get(:env) == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

	forward("/mailbox", Plug.Swoosh.MailboxPreview, base_path: "/dev/mailbox")
	end
	end

	scope "/" do
	pipe_through([:pleroma_html, :authenticate, :require_admin])
	live_dashboard("/phoenix/live_dashboard", additional_pages: [oban: Oban.LiveDashboard])
	end

	# Test-only routes needed to test action dispatching and plug chain execution
	if Pleroma.Config.get(:env) == :test do
	@test_actions [
	:do_oauth_check,
	:fallback_oauth_check,
	:skip_oauth_check,
	:fallback_oauth_skip_publicity_check,
	:skip_oauth_skip_publicity_check,
	:missing_oauth_check_definition
	]

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

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end

	scope "/test/authenticated_api", Pleroma.Tests do
	pipe_through(:authenticated_api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end
	end

	scope "/", Pleroma.Web.MongooseIM do
	get("/user_exists", MongooseIMController, :user_exists)
	get("/check_password", MongooseIMController, :check_password)
	end

	scope "/", Pleroma.Web.Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	match(:, "/api/pleroma/path", LegacyPleromaApiRerouterPlug, [])
	get("/api/*path", RedirectController, :api_not_implemented)
	get("/*path", RedirectController, :redirector_with_preload)

	options("/*path", RedirectController, :empty)
	end

	def get_api_routes do
	Phoenix.Router.routes(__MODULE__)
	\|> Enum.reject(fn r -> r.plug == Pleroma.Web.Fallback.RedirectController end)
	\|> Enum.map(fn r ->
	r.path
	\|> String.split("/", trim: true)
	\|> List.first()
	end)
	\|> Enum.uniq()
	end
	end
	diff --git a/test/pleroma/user_test.exs b/test/pleroma/user_test.exs
	index 0b4dc9197..b2533e9f1 100644
	--- a/test/pleroma/user_test.exs
	+++ b/test/pleroma/user_test.exs
	@@ -1,3010 +1,3015 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserTest do
	alias Pleroma.Activity
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase, async: false
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Swoosh.TestAssertions

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :account_activation_required])

	describe "service actors" do
	test "returns updated invisible actor" do
	uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	followers_uri = "#{uri}/followers"

	insert(
	:user,
	%{
	nickname: "relay",
	invisible: false,
	local: true,
	ap_id: uri,
	follower_address: followers_uri
	}
	)

	actor = User.get_or_create_service_actor_by_ap_id(uri, "relay")
	assert actor.invisible
	end

	test "returns relay user" do
	uri = "#{Pleroma.Web.Endpoint.url()}/relay"
	followers_uri = "#{uri}/followers"

	assert %User{
	nickname: "relay",
	invisible: true,
	local: true,
	ap_id: ^uri,
	follower_address: ^followers_uri
	} = User.get_or_create_service_actor_by_ap_id(uri, "relay")

	assert capture_log(fn ->
	refute User.get_or_create_service_actor_by_ap_id("/relay", "relay")
	end) =~ "Cannot create service actor:"
	end

	test "returns invisible actor" do
	uri = "#{Pleroma.Web.Endpoint.url()}/internal/fetch-test"
	followers_uri = "#{uri}/followers"
	user = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")

	assert %User{
	nickname: "internal.fetch-test",
	invisible: true,
	local: true,
	ap_id: ^uri,
	follower_address: ^followers_uri
	} = user

	user2 = User.get_or_create_service_actor_by_ap_id(uri, "internal.fetch-test")
	assert user.id == user2.id
	end
	end

	describe "AP ID user relationships" do
	setup do
	{:ok, user: insert(:user)}
	end

	test "outgoing_relationships_ap_ids/1", %{user: user} do
	rel_types = [:block, :mute, :notification_mute, :reblog_mute, :inverse_subscription]

	ap_ids_by_rel =
	Enum.into(
	rel_types,
	%{},
	fn rel_type ->
	rel_records =
	insert_list(2, :user_relationship, %{source: user, relationship_type: rel_type})

	ap_ids = Enum.map(rel_records, fn rr -> Repo.preload(rr, :target).target.ap_id end)
	{rel_type, Enum.sort(ap_ids)}
	end
	)

	assert ap_ids_by_rel[:block] == Enum.sort(User.blocked_users_ap_ids(user))
	assert ap_ids_by_rel[:block] == Enum.sort(Enum.map(User.blocked_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:mute] == Enum.sort(User.muted_users_ap_ids(user))
	assert ap_ids_by_rel[:mute] == Enum.sort(Enum.map(User.muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:notification_mute] ==
	Enum.sort(User.notification_muted_users_ap_ids(user))

	assert ap_ids_by_rel[:notification_mute] ==
	Enum.sort(Enum.map(User.notification_muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:reblog_mute] == Enum.sort(User.reblog_muted_users_ap_ids(user))

	assert ap_ids_by_rel[:reblog_mute] ==
	Enum.sort(Enum.map(User.reblog_muted_users(user), & &1.ap_id))

	assert ap_ids_by_rel[:inverse_subscription] == Enum.sort(User.subscriber_users_ap_ids(user))

	assert ap_ids_by_rel[:inverse_subscription] ==
	Enum.sort(Enum.map(User.subscriber_users(user), & &1.ap_id))

	outgoing_relationships_ap_ids = User.outgoing_relationships_ap_ids(user, rel_types)

	assert ap_ids_by_rel ==
	Enum.into(outgoing_relationships_ap_ids, %{}, fn {k, v} -> {k, Enum.sort(v)} end)
	end
	end

	describe "when tags are nil" do
	test "tagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.tag(user, ["cool", "dude"])

	assert "cool" in user.tags
	assert "dude" in user.tags
	end

	test "untagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.untag(user, ["cool", "dude"])

	assert user.tags == []
	end
	end

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "ap_following returns the following collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/following"

	assert expected_followers_collection == User.ap_following(user)
	end

	test "returns all pending follow requests" do
	unlocked = insert(:user)
	locked = insert(:user, is_locked: true)
	follower = insert(:user)

	CommonAPI.follow(unlocked, follower)
	CommonAPI.follow(locked, follower)

	assert [] = User.get_follow_requests(unlocked)
	assert [activity] = User.get_follow_requests(locked)

	assert activity
	end

	test "doesn't return already accepted or duplicate follow requests" do
	locked = insert(:user, is_locked: true)
	pending_follower = insert(:user)
	accepted_follower = insert(:user)

	CommonAPI.follow(locked, pending_follower)
	CommonAPI.follow(locked, pending_follower)
	CommonAPI.follow(locked, accepted_follower)

	Pleroma.FollowingRelationship.update(accepted_follower, locked, :follow_accept)

	assert [^pending_follower] = User.get_follow_requests(locked)
	end

	test "doesn't return follow requests for deactivated accounts" do
	locked = insert(:user, is_locked: true)
	pending_follower = insert(:user, %{is_active: false})

	CommonAPI.follow(locked, pending_follower)

	refute pending_follower.is_active
	assert [] = User.get_follow_requests(locked)
	end

	test "clears follow requests when requester is blocked" do
	followed = insert(:user, is_locked: true)
	follower = insert(:user)

	CommonAPI.follow(followed, follower)
	assert [_activity] = User.get_follow_requests(followed)

	{:ok, _user_relationship} = User.block(followed, follower)
	assert [] = User.get_follow_requests(followed)
	end

	test "follow_all follows multiple users" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	blocked = insert(:user)
	not_followed = insert(:user)
	reverse_blocked = insert(:user)

	{:ok, _user_relationship} = User.block(user, blocked)
	{:ok, _user_relationship} = User.block(reverse_blocked, user)

	{:ok, user, followed_zero} = User.follow(user, followed_zero)

	{:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])

	assert User.following?(user, followed_one)
	assert User.following?(user, followed_two)
	assert User.following?(user, followed_zero)
	refute User.following?(user, not_followed)
	refute User.following?(user, blocked)
	refute User.following?(user, reverse_blocked)
	end

	test "follow_all follows multiple users without duplicating" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)

	{:ok, user} = User.follow_all(user, [followed_zero, followed_one])
	assert length(User.following(user)) == 3

	{:ok, user} = User.follow_all(user, [followed_one, followed_two])
	assert length(User.following(user)) == 4
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed} = User.follow(user, followed)

	user = User.get_cached_by_id(user.id)
	followed = User.get_cached_by_ap_id(followed.ap_id)

	assert followed.follower_count == 1
	assert user.following_count == 1

	assert User.ap_followers(followed) in User.following(user)
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, %{is_active: false})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	test "can't subscribe to a user who blocked us" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blocked)

	{:error, _} = User.subscribe(blocked, blocker)
	end

	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, is_locked: true)
	followed = insert(:user, is_locked: true)

	{:ok, follower, followed} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	describe "unfollow/2" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "unfollow with synchronizes external user" do
	clear_config([:instance, :external_user_synchronization], true)

	followed =
	insert(:user,
	nickname: "fuser1",
	follower_address: "http://localhost:4001/users/fuser1/followers",
	following_address: "http://localhost:4001/users/fuser1/following",
	ap_id: "http://localhost:4001/users/fuser1"
	)

	user =
	insert(:user, %{
	local: false,
	nickname: "fuser2",
	ap_id: "http://localhost:4001/users/fuser2",
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	})

	{:ok, user, followed} = User.follow(user, followed, :follow_accept)

	{:ok, user, _activity} = User.unfollow(user, followed)

	user = User.get_cached_by_id(user.id)

	assert User.following(user) == []
	end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user)

	{:ok, user, followed} = User.follow(user, followed, :follow_accept)

	assert User.following(user) == [user.follower_address, followed.follower_address]

	{:ok, user, _activity} = User.unfollow(user, followed)

	assert User.following(user) == [user.follower_address]
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	assert User.following(user) == [user.follower_address]
	end
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user)
	User.follow(user, followed, :follow_accept)

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	test "fetches correct profile for nickname beginning with number" do
	# Use old-style integer ID to try to reproduce the problem
	user = insert(:user, %{id: 1080})
	user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
	assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do: clear_config([:instance, :autofollowed_nicknames])
	setup do: clear_config([:instance, :autofollowing_nicknames])
	setup do: clear_config([:welcome])
	setup do: clear_config([:instance, :account_activation_required])

	test "it autofollows accounts that are set for it" do
	user = insert(:user)
	remote_user = insert(:user, %{local: false})

	clear_config([:instance, :autofollowed_nicknames], [
	user.nickname,
	remote_user.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(registered_user, user)
	refute User.following?(registered_user, remote_user)
	end

	test "it adds automatic followers for new registered accounts" do
	user1 = insert(:user)
	user2 = insert(:user)

	clear_config([:instance, :autofollowing_nicknames], [
	user1.nickname,
	user2.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(user1, registered_user)
	assert User.following?(user2, registered_user)
	end

	test "it sends a welcome message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :direct_message, :enabled], true)
	clear_config([:welcome, :direct_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :direct_message, :message], "Hello, this is a direct message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "direct message"
	assert activity.actor == welcome_user.ap_id
	end

	test "it sends a welcome chat message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :chat_message, :enabled], true)
	clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "chat message"
	assert activity.actor == welcome_user.ap_id
	end

	setup do:
	clear_config(:mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	followers_only: [],
	accept: [],
	avatar_removal: [],
	banner_removal: [],
	reject_deletes: []
	)

	setup do: clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])

	test "it sends a welcome chat message when Simple policy applied to local instance" do
	clear_config([:mrf_simple, :media_nsfw], [{"localhost", ""}])

	welcome_user = insert(:user)
	clear_config([:welcome, :chat_message, :enabled], true)
	clear_config([:welcome, :chat_message, :sender_nickname], welcome_user.nickname)
	clear_config([:welcome, :chat_message, :message], "Hello, this is a chat message")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity, fetch: false).data["content"] =~ "chat message"
	assert activity.actor == welcome_user.ap_id
	end

	test "it sends a welcome email message if it is set" do
	welcome_user = insert(:user)
	clear_config([:welcome, :email, :enabled], true)
	clear_config([:welcome, :email, :sender], welcome_user.email)

	clear_config(
	[:welcome, :email, :subject],
	"Hello, welcome to cool site: <%= instance_name %>"
	)

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

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	assert_email_sent(
	from: {instance_name, welcome_user.email},
	to: {registered_user.name, registered_user.email},
	subject: "Hello, welcome to cool site: #{instance_name}",
	html_body: "Welcome to #{instance_name}"
	)
	end

	test "it sends a confirm email" do
	clear_config([:instance, :account_activation_required], true)

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)
	ObanHelpers.perform_all()

	Pleroma.Emails.UserEmail.account_confirmation_email(registered_user)
	# temporary hackney fix until hackney max_connections bug is fixed
	# https://git.pleroma.social/pleroma/pleroma/-/issues/2101
	\|> Swoosh.Email.put_private(:hackney_options, ssl_options: [versions: [:"tlsv1.2"]])
	\|> assert_email_sent()
	end

	test "sends a pending approval email" do
	clear_config([:instance, :account_approval_required], true)

	{:ok, user} =
	User.register_changeset(%User{}, @full_user_data)
	\|> User.register()

	ObanHelpers.perform_all()

	assert_email_sent(
	from: Pleroma.Config.Helpers.sender(),
	to: {user.name, user.email},
	subject: "Your account is awaiting approval"
	)
	end

	test "it sends a registration confirmed email if no others will be sent" do
	clear_config([:welcome, :email, :enabled], false)
	clear_config([:instance, :account_activation_required], false)
	clear_config([:instance, :account_approval_required], false)

	{:ok, user} =
	User.register_changeset(%User{}, @full_user_data)
	\|> User.register()

	ObanHelpers.perform_all()

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

	assert_email_sent(
	from: {instance_name, sender},
	to: {user.name, user.email},
	subject: "Account registered on #{instance_name}"
	)
	end

	test "it fails gracefully with invalid email config" do
	cng = User.register_changeset(%User{}, @full_user_data)

	# Disable the mailer but enable all the things that want to send emails
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([:instance, :account_activation_required], true)
	clear_config([:instance, :account_approval_required], true)
	clear_config([:welcome, :email, :enabled], true)
	clear_config([:welcome, :email, :sender], "lain@lain.com")

	# The user is still created
	assert {:ok, %User{nickname: "nick"}} = User.register(cng)

	# No emails are sent
	ObanHelpers.perform_all()
	refute_email_sent()
	end

	test "it works when the registering user does not provide an email" do
	clear_config([Pleroma.Emails.Mailer, :enabled], false)
	clear_config([:instance, :account_activation_required], false)
	clear_config([:instance, :account_approval_required], true)

	cng = User.register_changeset(%User{}, @full_user_data \|> Map.put(:email, ""))

	# The user is still created
	assert {:ok, %User{nickname: "nick"}} = User.register(cng)

	# No emails are sent
	ObanHelpers.perform_all()
	refute_email_sent()
	end

	test "it requires an email, name, nickname and password, bio is optional when account_activation_required is enabled" do
	clear_config([:instance, :account_activation_required], true)

	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it requires an name, nickname and password, bio and email are optional when account_activation_required is disabled" do
	clear_config([:instance, :account_activation_required], false)

	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key in [:bio, :email], do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it restricts certain nicknames" do
	clear_config([User, :restricted_nicknames], ["about"])
	[restricted_name \| _] = Pleroma.Config.get([User, :restricted_nicknames])

	assert is_binary(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_name)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end

	test "it is case-insensitive when restricting nicknames" do
	clear_config([User, :restricted_nicknames], ["about"])
	[restricted_name \| _] = Pleroma.Config.get([User, :restricted_nicknames])

	assert is_binary(restricted_name)

	restricted_upcase_name = String.upcase(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_upcase_name)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end

	test "it blocks blacklisted email domains" do
	clear_config([User, :email_blacklist], ["trolling.world"])

	# Block with match
	params = Map.put(@full_user_data, :email, "troll@trolling.world")
	changeset = User.register_changeset(%User{}, params)
	refute changeset.valid?

	# Block with case-insensitive match
	params = Map.put(@full_user_data, :email, "troll@TrOlLing.wOrld")
	changeset = User.register_changeset(%User{}, params)
	refute changeset.valid?

	# Block with subdomain match
	params = Map.put(@full_user_data, :email, "troll@gnomes.trolling.world")
	changeset = User.register_changeset(%User{}, params)
	refute changeset.valid?

	# Pass with different domains that are similar
	params = Map.put(@full_user_data, :email, "troll@gnomestrolling.world")
	changeset = User.register_changeset(%User{}, params)
	assert changeset.valid?

	params = Map.put(@full_user_data, :email, "troll@trolling.world.us")
	changeset = User.register_changeset(%User{}, params)
	assert changeset.valid?
	end

	test "it sets the password_hash, ap_id, private key and followers collection address" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert is_binary(changeset.changes[:keys])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end

	test "it sets the 'accepts_chat_messages' set to true" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.accepts_chat_messages
	end

	test "it creates a confirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.is_confirmed
	end
	end

	describe "user registration, with :account_activation_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}
	setup do: clear_config([:instance, :account_activation_required], true)

	test "it creates unconfirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.is_confirmed
	assert user.confirmation_token
	end

	test "it creates confirmed user if :confirmed option is given" do
	changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.is_confirmed
	refute user.confirmation_token
	end
	end

	describe "user registration, with :account_approval_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com",
	registration_reason: "I'm a cool guy :)"
	}
	setup do: clear_config([:instance, :account_approval_required], true)

	test "it creates unapproved user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.is_approved
	assert user.registration_reason == "I'm a cool guy :)"
	end

	test "it restricts length of registration reason" do
	reason_limit = Pleroma.Config.get([:instance, :registration_reason_length])

	assert is_integer(reason_limit)

	params =
	@full_user_data
	\|> Map.put(
	:registration_reason,
	"Quia et nesciunt dolores numquam ipsam nisi sapiente soluta. Ullam repudiandae nisi quam porro officiis officiis ad. Consequatur animi velit ex quia. Odit voluptatem perferendis quia ut nisi. Dignissimos sit soluta atque aliquid dolorem ut dolorum ut. Labore voluptates iste iusto amet voluptatum earum. Ad fugit illum nam eos ut nemo. Pariatur ea fuga non aspernatur. Dignissimos debitis officia corporis est nisi ab et. Atque itaque alias eius voluptas minus. Accusamus numquam tempore occaecati in."
	)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end
	end

	describe "user registration, with :birthday_required and :birthday_min_age" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do
	clear_config([:instance, :birthday_required], true)
	clear_config([:instance, :birthday_min_age], 18 * 365)
	end

	test "it passes when correct birth date is provided" do
	today = Date.utc_today()
	birthday = Date.add(today, -19 * 365)

	params =
	@full_user_data
	\|> Map.put(:birthday, birthday)

	changeset = User.register_changeset(%User{}, params)

	assert changeset.valid?
	end

	test "it fails when birth date is not provided" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	refute changeset.valid?
	end

	test "it fails when provided invalid birth date" do
	today = Date.utc_today()
	birthday = Date.add(today, -17 * 365)

	params =
	@full_user_data
	\|> Map.put(:birthday, birthday)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end
	end

	describe "get_or_fetch/1" do
	test "gets an existing user by nickname" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user by ap_id" do
	ap_id = "http://mastodon.example.org/users/admin"

	user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: ap_id
	)

	{:ok, fetched_user} = User.get_or_fetch(ap_id)
	freshed_user = refresh_record(user)
	assert freshed_user == fetched_user
	end

	test "gets an existing user by nickname starting with http" do
	user = insert(:user, nickname: "httpssome")
	{:ok, fetched_user} = User.get_or_fetch("httpssome")

	assert user == fetched_user
	end
	end

	describe "get_or_fetch/1 remote users with tld, while BE is running on a subdomain" do
	setup do: clear_config([Pleroma.Web.WebFinger, :update_nickname_on_user_fetch], true)

	test "for mastodon" do
	ap_id = "a@mastodon.example"
	{:ok, fetched_user} = User.get_or_fetch(ap_id)

	assert fetched_user.ap_id == "https://sub.mastodon.example/users/a"
	assert fetched_user.nickname == "a@mastodon.example"
	end

	test "for pleroma" do
	ap_id = "a@pleroma.example"
	{:ok, fetched_user} = User.get_or_fetch(ap_id)

	assert fetched_user.ap_id == "https://sub.pleroma.example/users/a"
	assert fetched_user.nickname == "a@pleroma.example"
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	{:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname" do
	user = insert(:user)

	{:ok, fetched_user} =
	User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname, case insensitive" do
	user = insert(:user, nickname: "nick")
	casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	{:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)

	assert user == fetched_user
	end

	test "returns nil if no user could be fetched" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistent@social.heldscal.la")
	assert fetched_user == "not found nonexistent@social.heldscal.la"
	end

	test "returns nil for nonexistent local user" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistent")
	assert fetched_user == "not found nonexistent"
	end

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")

	# Oban job was generated to refresh the stale user
	assert_enqueued(worker: "Pleroma.Workers.UserRefreshWorker", args: %{"ap_id" => user.ap_id})

	# Run job to refresh the user; just capture its output instead of fetching it again
	assert {:ok, updated_user} =
	perform_job(Pleroma.Workers.UserRefreshWorker, %{"ap_id" => user.ap_id})

	assert updated_user.inbox

	refute updated_user.last_refreshed_at == orig_user.last_refreshed_at
	end

	test "if nicknames clash, the old user gets a prefix with the old id to the nickname" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")

	assert user.inbox

	refute user.id == orig_user.id

	orig_user = User.get_by_id(orig_user.id)

	assert orig_user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
	end

	test "it returns the old user if stale, but unfetchable" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/raymoo",
	last_refreshed_at: a_week_ago
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/raymoo")

	assert user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.user_feed_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.user_feed_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	avatar: %{some: "avatar"}
	}
	setup do: clear_config([:instance, :user_bio_length])
	setup do: clear_config([:instance, :user_name_length])

	test "it confirms validity" do
	cs = User.remote_user_changeset(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_address" do
	cs = User.remote_user_changeset(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_changeset(%{@valid_remote \| nickname: "bla"})
	assert Ecto.Changeset.get_field(cs, :local) == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_changeset(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it is invalid given a local user" do
	user = insert(:user)
	cs = User.remote_user_changeset(user, %{name: "tom from myspace"})

	refute cs.valid?
	end

	test "it truncates fields" do
	clear_config([:instance, :max_remote_account_fields], 2)

	fields = [
	%{"name" => "One", "value" => "Uno"},
	%{"name" => "Two", "value" => "Dos"},
	%{"name" => "Three", "value" => "Tres"}
	]

	cs = User.remote_user_changeset(@valid_remote \|> Map.put(:fields, fields))

	assert [%{"name" => "One", "value" => "Uno"}, %{"name" => "Two", "value" => "Dos"}] ==
	Ecto.Changeset.get_field(cs, :fields)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one, user} = User.follow(follower_one, user)
	{:ok, follower_two, user} = User.follow(follower_two, user)

	res = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user, followed_one} = User.follow(user, followed_one)
	{:ok, user, followed_two} = User.follow(user, followed_two)

	res = User.get_friends(user)

	followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
	followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the note_count property" do
	note = insert(:note)

	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.update_note_count(user)

	assert user.note_count == 1
	end

	test "it increases the note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 2
	end

	test "it decreases the note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.note_count == 1

	{:ok, user} = User.decrease_note_count(user)

	assert user.note_count == 0

	{:ok, user} = User.decrease_note_count(user)

	assert user.note_count == 0
	end

	test "it sets the follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.follower_count == 0

	{:ok, user} = User.update_follower_count(user)

	assert user.follower_count == 1
	end
	end

	describe "mutes" do
	test "it mutes people" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

	{:ok, _user_relationships} = User.mute(user, muted_user)

	assert User.mutes?(user, muted_user)
	assert User.muted_notifications?(user, muted_user)
	end

	test "expiring" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user, %{duration: 60})
	assert User.mutes?(user, muted_user)

	worker = Pleroma.Workers.MuteExpireWorker
	args = %{"op" => "unmute_user", "muter_id" => user.id, "mutee_id" => muted_user.id}

	assert_enqueued(
	worker: worker,
	args: args
	)

	assert :ok = perform_job(worker, args)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it unmutes users" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user)
	{:ok, _user_mute} = User.unmute(user, muted_user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it unmutes users by id" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, _user_relationships} = User.mute(user, muted_user)
	{:ok, _user_mute} = User.unmute(user.id, muted_user.id)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it mutes user without notifications" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

	{:ok, _user_relationships} = User.mute(user, muted_user, %{notifications: false})

	assert User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

	{:ok, _user_relationship} = User.block(user, blocked_user)

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, _user_relationship} = User.block(user, blocked_user)
	{:ok, _user_block} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker, blocked} = User.follow(blocker, blocked)
	{:ok, blocked, blocker} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker, blocked} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked, blocker} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, _user_relationship} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker subscription relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, _subscription} = User.subscribe(blocked, blocker)

	assert User.subscribed_to?(blocked, blocker)
	refute User.subscribed_to?(blocker, blocked)

	{:ok, _user_relationship} = User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	refute User.subscribed_to?(blocker, blocked)
	refute User.subscribed_to?(blocked, blocker)
	end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end if wildcard added" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "blocks domain with wildcard for subdomain" do
	user = insert(:user)

	user_from_subdomain =
	insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})

	user_with_two_subdomains =
	insert(:user, %{
	ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
	})

	user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	assert User.blocks?(user, user_from_subdomain)
	assert User.blocks?(user, user_with_two_subdomains)
	assert User.blocks?(user, user_domain)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "follows take precedence over domain blocks" do
	user = insert(:user)
	good_eggo = insert(:user, %{ap_id: "https://meanies.social/user/cuteposter"})

	{:ok, user} = User.block_domain(user, "meanies.social")
	{:ok, user, good_eggo} = User.follow(user, good_eggo)

	refute User.blocks?(user, good_eggo)
	end
	end

	describe "get_recipients_from_activity" do
	test "works for announces" do
	actor = insert(:user)
	user = insert(:user, local: true)

	{:ok, activity} = CommonAPI.post(actor, %{status: "hello"})
	{:ok, announce} = CommonAPI.repeat(activity.id, user)

	recipients = User.get_recipients_from_activity(announce)

	assert user in recipients
	end

	test "get recipients" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	status: "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, user, actor} = User.follow(user, actor)
	{:ok, _user_two, _actor} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 3
	assert user in recipients
	assert addressed in recipients
	end

	test "has following" do
	actor = insert(:user)
	user = insert(:user)
	user_two = insert(:user)
	addressed = insert(:user, local: true)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	status: "hey @#{addressed.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, _actor, _user} = User.follow(actor, user)
	{:ok, _actor, _user_two} = User.follow(actor, user_two)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 2
	assert addressed in recipients
	end
	end

	describe ".set_activation" do
	test "can de-activate then re-activate a user" do
	user = insert(:user)
	assert user.is_active
	{:ok, user} = User.set_activation(user, false)
	refute user.is_active
	{:ok, user} = User.set_activation(user, true)
	assert user.is_active
	end

	test "hide a user from followers" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user, user2} = User.follow(user, user2)
	{:ok, _user} = User.set_activation(user, false)

	user2 = User.get_cached_by_id(user2.id)

	assert user2.follower_count == 0
	assert [] = User.get_followers(user2)
	end

	test "hide a user from friends" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2, user} = User.follow(user2, user)
	assert user2.following_count == 1
	assert User.following_count(user2) == 1

	{:ok, _user} = User.set_activation(user, false)

	user2 = User.get_cached_by_id(user2.id)

	assert refresh_record(user2).following_count == 0
	assert user2.following_count == 0
	assert User.following_count(user2) == 0
	assert [] = User.get_friends(user2)
	end

	test "hide a user's statuses from timelines and notifications" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2, user} = User.follow(user2, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{user2.nickname}"})

	activity = Repo.preload(activity, :bookmark)

	[notification] = Pleroma.Notification.for_user(user2)
	assert notification.activity.id == activity.id

	assert [activity] == ActivityPub.fetch_public_activities(%{}) \|> Repo.preload(:bookmark)

	assert [%{activity \| thread_muted?: CommonAPI.thread_muted?(activity, user2)}] ==
	ActivityPub.fetch_activities([user2.ap_id \| User.following(user2)], %{
	user: user2
	})

	{:ok, _user} = User.set_activation(user, false)

	assert [] == ActivityPub.fetch_public_activities(%{})
	assert [] == Pleroma.Notification.for_user(user2)

	assert [] ==
	ActivityPub.fetch_activities([user2.ap_id \| User.following(user2)], %{
	user: user2
	})
	end
	end

	describe "approve" do
	test "approves a user" do
	user = insert(:user, is_approved: false)
	refute user.is_approved
	{:ok, user} = User.approve(user)
	assert user.is_approved
	end

	test "approves a list of users" do
	unapproved_users = [
	insert(:user, is_approved: false),
	insert(:user, is_approved: false),
	insert(:user, is_approved: false)
	]

	{:ok, users} = User.approve(unapproved_users)

	assert Enum.count(users) == 3

	Enum.each(users, fn user ->
	assert user.is_approved
	end)
	end

	test "it sends welcome email if it is set" do
	clear_config([:welcome, :email, :enabled], true)
	clear_config([:welcome, :email, :sender], "tester@test.me")

	user = insert(:user, is_approved: false)
	welcome_user = insert(:user, email: "tester@test.me")
	instance_name = Pleroma.Config.get([:instance, :name])

	User.approve(user)

	ObanHelpers.perform_all()

	assert_email_sent(
	from: {instance_name, welcome_user.email},
	to: {user.name, user.email},
	html_body: "Welcome to #{instance_name}"
	)
	end

	test "approving an approved user does not trigger post-register actions" do
	clear_config([:welcome, :email, :enabled], true)

	user = insert(:user, is_approved: true)
	User.approve(user)

	ObanHelpers.perform_all()

	assert_no_email_sent()
	end
	end

	describe "confirm" do
	test "confirms a user" do
	user = insert(:user, is_confirmed: false)
	refute user.is_confirmed
	{:ok, user} = User.confirm(user)
	assert user.is_confirmed
	end

	test "confirms a list of users" do
	unconfirmed_users = [
	insert(:user, is_confirmed: false),
	insert(:user, is_confirmed: false),
	insert(:user, is_confirmed: false)
	]

	{:ok, users} = User.confirm(unconfirmed_users)

	assert Enum.count(users) == 3

	Enum.each(users, fn user ->
	assert user.is_confirmed
	end)
	end

	test "sends approval emails when `is_approved: false`" do
	admin = insert(:user, is_admin: true)
	user = insert(:user, is_confirmed: false, is_approved: false)
	User.confirm(user)

	ObanHelpers.perform_all()

	user_email = Pleroma.Emails.UserEmail.approval_pending_email(user)
	admin_email = Pleroma.Emails.AdminEmail.new_unapproved_registration(admin, user)

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

	# User approval email
	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: user_email.html_body
	)

	# Admin email
	assert_email_sent(
	from: {instance_name, notify_email},
	to: {admin.name, admin.email},
	html_body: admin_email.html_body
	)
	end

	test "confirming a confirmed user does not trigger post-register actions" do
	user = insert(:user, is_confirmed: true, is_approved: false)
	User.confirm(user)

	ObanHelpers.perform_all()

	assert_no_email_sent()
	end
	end

	describe "delete" do
	setup do
	{:ok, user} = insert(:user) \|> User.set_cache()

	[user: user]
	end

	setup do: clear_config([:instance, :federating])

	test ".delete_user_activities deletes all create activities", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{status: "2hu"})

	User.delete_user_activities(user)

	# TODO: Test removal favorites, repeats, delete activities.
	refute Activity.get_by_id(activity.id)
	end

	test "it deactivates a user, all follow relationships and all activities", %{user: user} do
	follower = insert(:user)
	{:ok, follower, user} = User.follow(follower, user)

	locked_user = insert(:user, name: "locked", is_locked: true)
	{:ok, _, _} = User.follow(user, locked_user, :follow_pending)

	object = insert(:note, user: user)
	activity = insert(:note_activity, user: user, note: object)

	object_two = insert(:note, user: follower)
	activity_two = insert(:note_activity, user: follower, note: object_two)

	{:ok, like} = CommonAPI.favorite(activity_two.id, user)
	{:ok, like_two} = CommonAPI.favorite(activity.id, follower)
	{:ok, repeat} = CommonAPI.repeat(activity_two.id, user)

	{:ok, job} = User.delete(user)
	{:ok, _user} = ObanHelpers.perform(job)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	assert %{is_active: false} = User.get_by_id(user.id)

	assert [] == User.get_follow_requests(locked_user)

	user_activities =
	user.ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.all()
	\|> Enum.map(fn act -> act.data["type"] end)

	assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)

	refute Activity.get_by_id(activity.id)
	refute Activity.get_by_id(like.id)
	refute Activity.get_by_id(like_two.id)
	refute Activity.get_by_id(repeat.id)
	end
	end

	test "delete/1 when confirmation is pending deletes the user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: false)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	refute User.get_cached_by_id(user.id)
	refute User.get_by_id(user.id)
	end

	test "delete/1 when approval is pending deletes the user" do
	user = insert(:user, is_approved: false)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	refute User.get_cached_by_id(user.id)
	refute User.get_by_id(user.id)
	end

	test "delete/1 purges a user when they wouldn't be fully deleted" do
	user =
	insert(:user, %{
	bio: "eyy lmao",
	name: "qqqqqqq",
	password_hash: "pdfk2$1b3n159001",
	keys: "RSA begin buplic key",
	public_key: "--PRIVATE KEYE--",
	avatar: %{"a" => "b"},
	tags: ["qqqqq"],
	banner: %{"a" => "b"},
	background: %{"a" => "b"},
	note_count: 9,
	follower_count: 9,
	following_count: 9001,
	is_locked: true,
	is_confirmed: true,
	password_reset_pending: true,
	is_approved: true,
	registration_reason: "ahhhhh",
	confirmation_token: "qqqq",
	domain_blocks: ["lain.com"],
	is_active: false,
	is_moderator: true,
	is_admin: true,
	mascot: %{"a" => "b"},
	emoji: %{"a" => "b"},
	pleroma_settings_store: %{"q" => "x"},
	fields: [%{"gg" => "qq"}],
	raw_fields: [%{"gg" => "qq"}],
	is_discoverable: true,
	also_known_as: ["https://lol.olo/users/loll"]
	})

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)
	user = User.get_by_id(user.id)

	assert %User{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	keys: "RSA begin buplic key",
	public_key: "--PRIVATE KEYE--",
	avatar: %{},
	tags: [],
	last_refreshed_at: nil,
	last_digest_emailed_at: nil,
	banner: %{},
	background: %{},
	note_count: 0,
	follower_count: 0,
	following_count: 0,
	is_locked: false,
	is_confirmed: true,
	password_reset_pending: false,
	is_approved: true,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	is_active: false,
	is_moderator: false,
	is_admin: false,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	} = user
	end

	test "delete/1 purges a remote user" do
	user =
	insert(:user, %{
	name: "qqqqqqq",
	avatar: %{"a" => "b"},
	banner: %{"a" => "b"},
	local: false
	})

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)
	user = User.get_by_id(user.id)

	assert user.name == nil
	assert user.avatar == %{}
	assert user.banner == %{}
	end

	describe "set_suggestion" do
	test "suggests a user" do
	user = insert(:user, is_suggested: false)
	refute user.is_suggested
	{:ok, user} = User.set_suggestion(user, true)
	assert user.is_suggested
	end

	test "suggests a list of users" do
	unsuggested_users = [
	insert(:user, is_suggested: false),
	insert(:user, is_suggested: false),
	insert(:user, is_suggested: false)
	]

	{:ok, users} = User.set_suggestion(unsuggested_users, true)

	assert Enum.count(users) == 3

	Enum.each(users, fn user ->
	assert user.is_suggested
	end)
	end

	test "unsuggests a user" do
	user = insert(:user, is_suggested: true)
	assert user.is_suggested
	{:ok, user} = User.set_suggestion(user, false)
	refute user.is_suggested
	end
	end

	+ test "get_or_fetch_public_key_for_ap_id fetches a user that's not in the db" do
	+ assert {:ok, _key} =
	+ User.get_or_fetch_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	+ end
	+
	test "get_public_key_for_ap_id returns correctly for user that's not in the db" do
	assert :error = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns default policies, when rich-text is enabled" do
	user = insert(:user)

	assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, no_rich_text: true)

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)

	User.set_cache(user)
	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

	{:ok, job} = User.delete(user)
	{:ok, _} = ObanHelpers.perform(job)

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	describe "account_status/1" do
	setup do: clear_config([:instance, :account_activation_required])

	test "return confirmation_pending for unconfirm user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: false)
	assert User.account_status(user) == :confirmation_pending
	end

	test "return active for confirmed user" do
	clear_config([:instance, :account_activation_required], true)
	user = insert(:user, is_confirmed: true)
	assert User.account_status(user) == :active
	end

	test "return active for remote user" do
	user = insert(:user, local: false)
	assert User.account_status(user) == :active
	end

	test "returns :password_reset_pending for user with reset password" do
	user = insert(:user, password_reset_pending: true)
	assert User.account_status(user) == :password_reset_pending
	end

	test "returns :deactivated for deactivated user" do
	user = insert(:user, local: true, is_confirmed: true, is_active: false)
	assert User.account_status(user) == :deactivated
	end

	test "returns :approval_pending for unapproved user" do
	user = insert(:user, local: true, is_approved: false)
	assert User.account_status(user) == :approval_pending

	user = insert(:user, local: true, is_confirmed: false, is_approved: false)
	assert User.account_status(user) == :approval_pending
	end
	end

	describe "privileged?/1" do
	setup do
	clear_config([:instance, :admin_privileges], [:cofe, :suya])
	clear_config([:instance, :moderator_privileges], [:cofe, :suya])
	end

	test "returns false for unprivileged users" do
	user = insert(:user, local: true)

	refute User.privileged?(user, :cofe)
	end

	test "returns false for remote users" do
	user = insert(:user, local: false)
	remote_admin_user = insert(:user, local: false, is_admin: true)

	refute User.privileged?(user, :cofe)
	refute User.privileged?(remote_admin_user, :cofe)
	end

	test "returns true for local moderators if, and only if, they are privileged" do
	user = insert(:user, local: true, is_moderator: true)

	assert User.privileged?(user, :cofe)

	clear_config([:instance, :moderator_privileges], [])

	refute User.privileged?(user, :cofe)
	end

	test "returns true for local admins if, and only if, they are privileged" do
	user = insert(:user, local: true, is_admin: true)

	assert User.privileged?(user, :cofe)

	clear_config([:instance, :admin_privileges], [])

	refute User.privileged?(user, :cofe)
	end
	end

	describe "privileges/1" do
	setup do
	clear_config([:instance, :moderator_privileges], [:cofe, :only_moderator])
	clear_config([:instance, :admin_privileges], [:cofe, :only_admin])
	end

	test "returns empty list for users without roles" do
	user = insert(:user, local: true)

	assert [] == User.privileges(user)
	end

	test "returns list of privileges for moderators" do
	moderator = insert(:user, is_moderator: true, local: true)

	assert [:cofe, :only_moderator] == User.privileges(moderator) \|> Enum.sort()
	end

	test "returns list of privileges for admins" do
	admin = insert(:user, is_admin: true, local: true)

	assert [:cofe, :only_admin] == User.privileges(admin) \|> Enum.sort()
	end

	test "returns list of unique privileges for users who are both moderator and admin" do
	moderator_admin = insert(:user, is_moderator: true, is_admin: true, local: true)

	assert [:cofe, :only_admin, :only_moderator] ==
	User.privileges(moderator_admin) \|> Enum.sort()
	end

	test "returns empty list for remote users" do
	remote_moderator_admin = insert(:user, is_moderator: true, is_admin: true, local: false)

	assert [] == User.privileges(remote_moderator_admin)
	end
	end

	describe "invisible?/1" do
	test "returns true for an invisible user" do
	user = insert(:user, local: true, invisible: true)

	assert User.invisible?(user)
	end

	test "returns false for a non-invisible user" do
	user = insert(:user, local: true)

	refute User.invisible?(user)
	end
	end

	describe "visible_for/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for(user, user) == :visible
	end

	test "returns false when the account is unconfirmed and confirmation is required" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: true, is_confirmed: false)
	other_user = insert(:user, local: true)

	refute User.visible_for(user, other_user) == :visible
	end

	test "returns true when the account is unconfirmed and confirmation is required but the account is remote" do
	clear_config([:instance, :account_activation_required], true)

	user = insert(:user, local: false, is_confirmed: false)
	other_user = insert(:user, local: true)

	assert User.visible_for(user, other_user) == :visible
	end

	test "returns true when the account is unconfirmed and being viewed by a privileged account (privilege :users_manage_activation_state, confirmation required)" do
	clear_config([:instance, :account_activation_required], true)
	clear_config([:instance, :admin_privileges], [:users_manage_activation_state])

	user = insert(:user, local: true, is_confirmed: false)
	other_user = insert(:user, local: true, is_admin: true)

	assert User.visible_for(user, other_user) == :visible

	clear_config([:instance, :admin_privileges], [])

	refute User.visible_for(user, other_user) == :visible
	end
	end

	describe "all_users_with_privilege/1" do
	setup do
	%{
	user: insert(:user, local: true, is_admin: false, is_moderator: false),
	moderator_user: insert(:user, local: true, is_admin: false, is_moderator: true),
	admin_user: insert(:user, local: true, is_admin: true, is_moderator: false),
	admin_moderator_user: insert(:user, local: true, is_admin: true, is_moderator: true),
	remote_user: insert(:user, local: false, is_admin: true, is_moderator: true),
	non_active_user:
	insert(:user, local: true, is_admin: true, is_moderator: true, is_active: false)
	}
	end

	test "doesn't return any users when there are no privileged roles" do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [])

	assert [] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	end

	test "returns moderator users if they are privileged", %{
	moderator_user: moderator_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [])
	clear_config([:instance, :moderator_privileges], [:cofe])

	assert [_, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert moderator_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end

	test "returns admin users if they are privileged", %{
	admin_user: admin_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [:cofe])
	clear_config([:instance, :moderator_privileges], [])

	assert [_, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert admin_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end

	test "returns admin and moderator users if they are both privileged", %{
	moderator_user: moderator_user,
	admin_user: admin_user,
	admin_moderator_user: admin_moderator_user
	} do
	clear_config([:instance, :admin_privileges], [:cofe])
	clear_config([:instance, :moderator_privileges], [:cofe])

	assert [_, _, _] = User.Query.build(%{is_privileged: :cofe}) \|> Repo.all()
	assert admin_user in User.all_users_with_privilege(:cofe)
	assert moderator_user in User.all_users_with_privilege(:cofe)
	assert admin_moderator_user in User.all_users_with_privilege(:cofe)
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	~s(A.k.a. <span class="h-card"><a class="u-url mention" data-user="#{remote_user.id}" href="#{remote_user.ap_id}" rel="ugc">@<span>nick@domain.com</span></a></span>)

	assert expected_text == User.parse_bio(bio, user)
	end

	test "Adds rel=me on linkbacked urls" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	bio = "http://example.com/rel_me/null"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/link"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.com/rel_me/anchor"
	expected_text = "<a href=\"#{bio}\" rel=\"me\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "follower count is updated when a follower is blocked" do
	user = insert(:user)
	follower = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)

	{:ok, follower, user} = User.follow(follower, user)
	{:ok, _follower2, _user} = User.follow(follower2, user)
	{:ok, _follower3, _user} = User.follow(follower3, user)

	{:ok, _user_relationship} = User.block(user, follower)
	user = refresh_record(user)

	assert user.follower_count == 2
	end

	describe "list_inactive_users_query/1" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Users are inactive by default" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(users, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users who has no recent activity" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	{inactive, active} = Enum.split(users, trunc(total / 2))

	Enum.map(active, fn user ->
	to = Enum.random(users -- [user])

	{:ok, _} =
	CommonAPI.post(user, %{
	status: "hey @#{to.nickname}"
	})
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users with no read notifications" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), is_active: true)
	end)

	[sender \| recipients] = users
	{inactive, active} = Enum.split(recipients, trunc(total / 2))

	Enum.each(recipients, fn to ->
	{:ok, _} =
	CommonAPI.post(sender, %{
	status: "hey @#{to.nickname}"
	})

	{:ok, _} =
	CommonAPI.post(sender, %{
	status: "hey again @#{to.nickname}"
	})
	end)

	Enum.each(active, fn user ->
	[n1, _n2] = Pleroma.Notification.for_user(user)
	{:ok, _} = Pleroma.Notification.read_one(user, n1.id)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end
	end

	describe "get_ap_ids_by_nicknames" do
	test "it returns a list of AP ids for a given set of nicknames" do
	user = insert(:user)
	user_two = insert(:user)

	ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
	assert length(ap_ids) == 2
	assert user.ap_id in ap_ids
	assert user_two.ap_id in ap_ids
	end

	test "it returns a list of AP ids in the same order" do
	user = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	ap_ids =
	User.get_ap_ids_by_nicknames([user.nickname, user_three.nickname, user_two.nickname])

	assert [user.ap_id, user_three.ap_id, user_two.ap_id] == ap_ids
	end
	end

	describe "sync followers count" do
	setup do
	user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
	user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
	insert(:user, local: true)
	insert(:user, local: false, is_active: false)
	{:ok, user1: user1, user2: user2}
	end

	test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
	[fdb_user1] = User.external_users(limit: 1)

	assert fdb_user1.ap_id
	assert fdb_user1.ap_id == user1.ap_id
	assert fdb_user1.id == user1.id

	[fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)

	assert fdb_user2.ap_id
	assert fdb_user2.ap_id == user2.ap_id
	assert fdb_user2.id == user2.id

	assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
	end
	end

	describe "internal?/1" do
	test "non-internal user returns false" do
	user = insert(:user)
	refute User.internal?(user)
	end

	test "user with no nickname returns true" do
	user = insert(:user, %{nickname: nil})
	assert User.internal?(user)
	end

	test "user with internal-prefixed nickname returns true" do
	user = insert(:user, %{nickname: "internal.test"})
	assert User.internal?(user)
	end
	end

	describe "update_and_set_cache/1" do
	test "returns error when user is stale instead Ecto.StaleEntryError" do
	user = insert(:user)

	changeset = Ecto.Changeset.change(user, bio: "test")

	Repo.delete(user)

	assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
	User.update_and_set_cache(changeset)
	end

	test "performs update cache if user updated" do
	user = insert(:user)
	assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	changeset = Ecto.Changeset.change(user, bio: "test-bio")

	assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
	assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
	end
	end

	describe "following/followers synchronization" do
	setup do: clear_config([:instance, :external_user_synchronization])

	test "updates the counters normally on following/getting a follow when disabled" do
	clear_config([:instance, :external_user_synchronization], false)
	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	{:ok, user, other_user} = Pleroma.User.follow(user, other_user)

	assert user.following_count == 1
	assert other_user.follower_count == 1
	end

	test "synchronizes the counters with the remote instance for the followed when enabled" do
	clear_config([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	clear_config([:instance, :external_user_synchronization], true)
	{:ok, _user, other_user} = User.follow(user, other_user)

	assert other_user.follower_count == 437
	end

	test "synchronizes the counters with the remote instance for the follower when enabled" do
	clear_config([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "https://remote.org/users/masto_closed/followers",
	following_address: "https://remote.org/users/masto_closed/following"
	)

	assert other_user.following_count == 0
	assert other_user.follower_count == 0

	clear_config([:instance, :external_user_synchronization], true)
	{:ok, other_user, _user} = User.follow(other_user, user)

	assert other_user.following_count == 152
	end
	end

	describe "change_email/2" do
	setup do
	[user: insert(:user)]
	end

	test "blank email returns error if we require an email on registration", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

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

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

	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, "")
	assert {:error, %{errors: [email: {"can't be blank", _}]}} = User.change_email(user, nil)
	end

	test "blank email should be fine if we do not require an email on registration", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

	Pleroma.Config.put([:instance, :account_activation_required], false)

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

	assert {:ok, %User{email: nil}} = User.change_email(user, "")
	assert {:ok, %User{email: nil}} = User.change_email(user, nil)
	end

	test "non unique email returns error", %{user: user} do
	%{email: email} = insert(:user)

	assert {:error, %{errors: [email: {"has already been taken", _}]}} =
	User.change_email(user, email)
	end

	test "invalid email returns error", %{user: user} do
	assert {:error, %{errors: [email: {"has invalid format", _}]}} =
	User.change_email(user, "cofe")
	end

	test "changes email", %{user: user} do
	assert {:ok, %User{email: "cofe@cofe.party"}} = User.change_email(user, "cofe@cofe.party")
	end

	test "adds email", %{user: user} do
	orig_account_activation_required =
	Pleroma.Config.get([:instance, :account_activation_required])

	Pleroma.Config.put([:instance, :account_activation_required], false)

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

	assert {:ok, _} = User.change_email(user, "")
	Pleroma.Config.put([:instance, :account_activation_required], true)

	assert {:ok, %User{email: "cofe2@cofe.party"}} = User.change_email(user, "cofe2@cofe.party")
	end
	end

	describe "get_cached_by_nickname_or_id" do
	setup do
	local_user = insert(:user)
	remote_user = insert(:user, nickname: "nickname@example.com", local: false)

	[local_user: local_user, remote_user: remote_user]
	end

	setup do: clear_config([:instance, :limit_to_local_content])

	test "allows getting remote users by id no matter what :limit_to_local_content is set to", %{
	remote_user: remote_user
	} do
	clear_config([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	clear_config([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)

	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.id)
	end

	test "disallows getting remote users by nickname without authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user} do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting remote users by nickname with authentication when :limit_to_local_content is set to :unauthenticated",
	%{remote_user: remote_user, local_user: local_user} do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(remote_user.nickname, for: local_user)
	end

	test "disallows getting remote users by nickname when :limit_to_local_content is set to true",
	%{remote_user: remote_user} do
	clear_config([:instance, :limit_to_local_content], true)
	assert nil == User.get_cached_by_nickname_or_id(remote_user.nickname)
	end

	test "allows getting local users by nickname no matter what :limit_to_local_content is set to",
	%{local_user: local_user} do
	clear_config([:instance, :limit_to_local_content], false)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	clear_config([:instance, :limit_to_local_content], true)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)

	clear_config([:instance, :limit_to_local_content], :unauthenticated)
	assert %User{} = User.get_cached_by_nickname_or_id(local_user.nickname)
	end
	end

	describe "update_email_notifications/2" do
	setup do
	user = insert(:user, email_notifications: %{"digest" => true})

	{:ok, user: user}
	end

	test "Notifications are updated", %{user: user} do
	true = user.email_notifications["digest"]
	assert {:ok, result} = User.update_email_notifications(user, %{"digest" => false})
	assert result.email_notifications["digest"] == false
	end
	end

	describe "local_nickname/1" do
	test "returns nickname without host" do
	assert User.local_nickname("@mentioned") == "mentioned"
	assert User.local_nickname("a_local_nickname") == "a_local_nickname"
	assert User.local_nickname("nickname@host.com") == "nickname"
	end
	end

	describe "full_nickname/1" do
	test "returns fully qualified nickname for local users" do
	local_user = insert(:user, nickname: "local_user")

	assert User.full_nickname(local_user) == "local_user@localhost"
	end

	test "returns fully qualified nickname for local users when using different domain for webfinger" do
	clear_config([Pleroma.Web.WebFinger, :domain], "plemora.dev")

	local_user = insert(:user, nickname: "local_user")

	assert User.full_nickname(local_user) == "local_user@plemora.dev"
	end

	test "returns fully qualified nickname for remote users" do
	remote_user = insert(:user, nickname: "remote@host.com", local: false)

	assert User.full_nickname(remote_user) == "remote@host.com"
	end

	test "strips leading @ from mentions" do
	assert User.full_nickname("@mentioned") == "mentioned"
	assert User.full_nickname("@nickname@host.com") == "nickname@host.com"
	end

	test "does not modify nicknames" do
	assert User.full_nickname("nickname") == "nickname"
	assert User.full_nickname("nickname@host.com") == "nickname@host.com"
	end
	end

	test "avatar fallback" do
	user = insert(:user)
	assert User.avatar_url(user) =~ "/images/avi.png"

	clear_config([:assets, :default_user_avatar], "avatar.png")

	user = User.get_cached_by_nickname_or_id(user.nickname)
	assert User.avatar_url(user) =~ "avatar.png"

	assert User.avatar_url(user, no_default: true) == nil
	end

	test "get_host/1" do
	user = insert(:user, ap_id: "https://lain.com/users/lain", nickname: "lain")
	assert User.get_host(user) == "lain.com"
	end

	test "update_last_active_at/1" do
	user = insert(:user)
	assert is_nil(user.last_active_at)

	test_started_at = NaiveDateTime.utc_now() \|> NaiveDateTime.truncate(:second)

	assert {:ok, user} = User.update_last_active_at(user)

	assert NaiveDateTime.compare(user.last_active_at, test_started_at) in [:gt, :eq]

	assert NaiveDateTime.compare(
	user.last_active_at,
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	) in [:lt, :eq]

	last_active_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(-:timer.hours(24), :millisecond)
	\|> NaiveDateTime.truncate(:second)

	assert {:ok, user} =
	user
	\|> cast(%{last_active_at: last_active_at}, [:last_active_at])
	\|> User.update_and_set_cache()

	assert NaiveDateTime.compare(user.last_active_at, last_active_at) == :eq

	assert {:ok, user} = User.update_last_active_at(user)
	assert NaiveDateTime.compare(user.last_active_at, test_started_at) in [:gt, :eq]

	assert NaiveDateTime.compare(
	user.last_active_at,
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	) in [:lt, :eq]
	end

	test "active_user_count/1" do
	insert(:user)
	insert(:user, %{local: false})
	insert(:user, %{last_active_at: NaiveDateTime.utc_now()})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), days: -15)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), weeks: -6)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), months: -7)})
	insert(:user, %{last_active_at: Timex.shift(NaiveDateTime.utc_now(), years: -2)})

	assert User.active_user_count() == 2
	assert User.active_user_count(180) == 3
	assert User.active_user_count(365) == 4
	assert User.active_user_count(1000) == 5
	end

	describe "pins" do
	setup do
	user = insert(:user)

	[user: user, object_id: object_id_from_created_activity(user)]
	end

	test "unique pins", %{user: user, object_id: object_id} do
	assert {:ok, %{pinned_objects: %{^object_id => pinned_at1} = pins} = updated_user} =
	User.add_pinned_object_id(user, object_id)

	assert Enum.count(pins) == 1

	assert {:ok, %{pinned_objects: %{^object_id => pinned_at2} = pins}} =
	User.add_pinned_object_id(updated_user, object_id)

	assert pinned_at1 == pinned_at2

	assert Enum.count(pins) == 1
	end

	test "respects max_pinned_statuses limit", %{user: user, object_id: object_id} do
	clear_config([:instance, :max_pinned_statuses], 1)
	{:ok, updated} = User.add_pinned_object_id(user, object_id)

	object_id2 = object_id_from_created_activity(user)

	{:error, %{errors: errors}} = User.add_pinned_object_id(updated, object_id2)
	assert Keyword.has_key?(errors, :pinned_objects)
	end

	test "remove_pinned_object_id/2", %{user: user, object_id: object_id} do
	assert {:ok, updated} = User.add_pinned_object_id(user, object_id)

	{:ok, after_remove} = User.remove_pinned_object_id(updated, object_id)
	assert after_remove.pinned_objects == %{}
	end
	end

	defp object_id_from_created_activity(user) do
	%{id: id} = insert(:note_activity, user: user)
	%{object: %{data: %{"id" => object_id}}} = Activity.get_by_id_with_object(id)
	object_id
	end

	describe "add_alias/2" do
	test "should add alias for another user" do
	user = insert(:user)
	user2 = insert(:user)

	assert {:ok, user_updated} = user \|> User.add_alias(user2)

	assert user_updated.also_known_as \|> length() == 1
	assert user2.ap_id in user_updated.also_known_as
	end

	test "should add multiple aliases" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	assert {:ok, user} = user \|> User.add_alias(user2)
	assert {:ok, user_updated} = user \|> User.add_alias(user3)

	assert user_updated.also_known_as \|> length() == 2
	assert user2.ap_id in user_updated.also_known_as
	assert user3.ap_id in user_updated.also_known_as
	end

	test "should not add duplicate aliases" do
	user = insert(:user)
	user2 = insert(:user)

	assert {:ok, user} = user \|> User.add_alias(user2)

	assert {:ok, user_updated} = user \|> User.add_alias(user2)

	assert user_updated.also_known_as \|> length() == 1
	assert user2.ap_id in user_updated.also_known_as
	end

	test "should tolerate non-http(s) aliases" do
	user =
	insert(:user, %{
	also_known_as: ["at://did:plc:xgvzy7ni6ig6ievcbls5jaxe"]
	})

	assert "at://did:plc:xgvzy7ni6ig6ievcbls5jaxe" in user.also_known_as
	end
	end

	describe "alias_users/1" do
	test "should get aliases for a user" do
	user = insert(:user)
	user2 = insert(:user, also_known_as: [user.ap_id])

	aliases = user2 \|> User.alias_users()

	assert aliases \|> length() == 1

	alias_user = aliases \|> Enum.at(0)

	assert alias_user.ap_id == user.ap_id
	end
	end

	describe "delete_alias/2" do
	test "should delete existing alias" do
	user = insert(:user)
	user2 = insert(:user, also_known_as: [user.ap_id])

	assert {:ok, user_updated} = user2 \|> User.delete_alias(user)

	assert user_updated.also_known_as == []
	end

	test "should report error on non-existing alias" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user, also_known_as: [user.ap_id])

	assert {:error, :no_such_alias} = user3 \|> User.delete_alias(user2)

	user3_updated = User.get_cached_by_ap_id(user3.ap_id)

	assert user3_updated.also_known_as \|> length() == 1
	assert user.ap_id in user3_updated.also_known_as
	end
	end

	describe "get_familiar_followers/3" do
	test "returns familiar followers for a pair of users" do
	user1 = insert(:user)
	%{id: id2} = user2 = insert(:user)
	user3 = insert(:user)
	_user4 = insert(:user)

	User.follow(user1, user2)
	User.follow(user2, user3)

	assert [%{id: ^id2}] = User.get_familiar_followers(user3, user1)
	end
	end

	describe "account endorsements" do
	test "it pins people" do
	user = insert(:user)
	pinned_user = insert(:user)

	{:ok, _pinned_user, _user} = User.follow(user, pinned_user)

	refute User.endorses?(user, pinned_user)

	{:ok, _user_relationship} = User.endorse(user, pinned_user)

	assert User.endorses?(user, pinned_user)
	end

	test "it unpins users" do
	user = insert(:user)
	pinned_user = insert(:user)

	{:ok, _pinned_user, _user} = User.follow(user, pinned_user)
	{:ok, _user_relationship} = User.endorse(user, pinned_user)
	{:ok, _user_pin} = User.unendorse(user, pinned_user)

	refute User.endorses?(user, pinned_user)
	end

	test "it doesn't pin users you do not follow" do
	user = insert(:user)
	pinned_user = insert(:user)

	assert {:error, _message} = User.endorse(user, pinned_user)

	refute User.endorses?(user, pinned_user)
	end
	end

	test "it checks fields links for a backlink" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	fields = [
	%{"name" => "Link", "value" => "http://example.com/rel_me/null"},
	%{"name" => "Verified link", "value" => "http://example.com/rel_me/link"},
	%{"name" => "Not a link", "value" => "i'm not a link"}
	]

	user
	\|> User.update_and_set_cache(%{raw_fields: fields})

	ObanHelpers.perform_all()

	user = User.get_cached_by_id(user.id)

	assert [
	%{"verified_at" => nil},
	%{"verified_at" => verified_at},
	%{"verified_at" => nil}
	] = user.fields

	assert is_binary(verified_at)
	end

	test "updating fields does not invalidate previously validated links" do
	user = insert(:user, ap_id: "https://social.example.org/users/lain")

	user
	\|> User.update_and_set_cache(%{
	raw_fields: [%{"name" => "verified link", "value" => "http://example.com/rel_me/link"}]
	})

	ObanHelpers.perform_all()

	%User{fields: [%{"verified_at" => verified_at}]} = user = User.get_cached_by_id(user.id)

	user
	\|> User.update_and_set_cache(%{
	raw_fields: [%{"name" => "Verified link", "value" => "http://example.com/rel_me/link"}]
	})

	user = User.get_cached_by_id(user.id)

	assert [%{"verified_at" => ^verified_at}] = user.fields
	end

	describe "follow_hashtag/2" do
	test "should follow a hashtag" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 1
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end

	test "should not follow a hashtag twice" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 1
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end

	test "can follow multiple hashtags" do
	user = insert(:user)
	hashtag = insert(:hashtag)
	other_hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.follow_hashtag(other_hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 2
	assert hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	assert other_hashtag.name in Enum.map(user.followed_hashtags, fn %{name: name} -> name end)
	end
	end

	describe "unfollow_hashtag/2" do
	test "should unfollow a hashtag" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 0
	end

	test "should not error when trying to unfollow a hashtag twice" do
	user = insert(:user)
	hashtag = insert(:hashtag)

	assert {:ok, _} = user \|> User.follow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)
	assert {:ok, _} = user \|> User.unfollow_hashtag(hashtag)

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.followed_hashtags \|> Enum.count() == 0
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/publisher_test.exs b/test/pleroma/web/activity_pub/publisher_test.exs
	index a55993978..1f9e0bfe5 100644
	--- a/test/pleroma/web/activity_pub/publisher_test.exs
	+++ b/test/pleroma/web/activity_pub/publisher_test.exs
	@@ -1,578 +1,605 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.PublisherTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import Tesla.Mock

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Publisher
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	@as_public "https://www.w3.org/ns/activitystreams#Public"

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup_all do: clear_config([:instance, :federating], true)

	describe "should_federate?/1" do
	test "it returns false when the inbox is nil" do
	refute Publisher.should_federate?(nil, false)
	refute Publisher.should_federate?(nil, true)
	end

	test "it returns true when public is true" do
	assert Publisher.should_federate?(false, true)
	end
	end

	describe "gather_webfinger_links/1" do
	test "it returns links" do
	user = insert(:user)

	expected_links = [
	%{"href" => user.ap_id, "rel" => "self", "type" => "application/activity+json"},
	%{
	"href" => user.ap_id,
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	"template" => "#{Pleroma.Web.Endpoint.url()}/ostatus_subscribe?acct={uri}"
	}
	]

	assert expected_links == Publisher.gather_webfinger_links(user)
	end
	end

	describe "determine_inbox/2" do
	test "it returns sharedInbox for messages involving as:Public in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"to" => [@as_public], "cc" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving as:Public in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})

	activity = %Activity{
	data: %{"cc" => [@as_public], "to" => [user.follower_address]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in to" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"cc" => [], "to" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in cc" do
	user = insert(:user, %{shared_inbox: "http://example.com/inbox"})
	user_two = insert(:user)
	user_three = insert(:user)

	activity = %Activity{
	data: %{"to" => [], "cc" => [user.ap_id, user_two.ap_id, user_three.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns sharedInbox for messages involving multiple recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	user_two = insert(:user)

	activity = %Activity{
	data: %{"to" => [user_two.ap_id], "cc" => [user.ap_id]}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/inbox"
	end

	test "it returns inbox for messages involving single recipients in total" do
	user =
	insert(:user, %{
	shared_inbox: "http://example.com/inbox",
	inbox: "http://example.com/personal-inbox"
	})

	activity = %Activity{
	data: %{"to" => [user.ap_id], "cc" => []}
	}

	assert Publisher.determine_inbox(activity, user) == "http://example.com/personal-inbox"
	end
	end

	describe "publish_one/1" do
	test "publish to url with with different ports" do
	inbox80 = "http://42.site/users/nick1/inbox"
	inbox42 = "http://42.site:42/users/nick1/inbox"
	activity = insert(:note_activity)

	mock(fn
	%{method: :post, url: "http://42.site:42/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 42"}}

	%{method: :post, url: "http://42.site/users/nick1/inbox"} ->
	{:ok, %Tesla.Env{status: 200, body: "port 80"}}
	end)

	_actor = insert(:user)

	assert {:ok, %{body: "port 42"}} =
	Publisher.prepare_one(%{
	inbox: inbox42,
	activity_id: activity.id,
	unreachable_since: true
	})
	\|> Publisher.publish_one()

	assert {:ok, %{body: "port 80"}} =
	Publisher.prepare_one(%{
	inbox: inbox80,
	activity_id: activity.id,
	unreachable_since: true
	})
	\|> Publisher.publish_one()
	end
	end

	describe "publish/2" do
	test "doesn't publish a non-public activity to quarantined instances." do
	Config.put([:instance, :quarantined_instances], [{"domain.com", "some reason"}])

	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)
	actor = refresh_record(actor)

	note_activity =
	insert(:followers_only_note_activity,
	user: actor,
	recipients: [follower.ap_id]
	)

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	refute_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: note_activity.id
	}
	}
	)
	end

	test "Publishes a non-public activity to non-quarantined instances." do
	Config.put([:instance, :quarantined_instances], [{"somedomain.com", "some reason"}])

	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)
	actor = refresh_record(actor)

	note_activity =
	insert(:followers_only_note_activity,
	user: actor,
	recipients: [follower.ap_id]
	)

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: note_activity.id
	}
	},
	priority: 1
	)
	end

	test "Publishes to directly addressed actors with higher priority." do
	note_activity = insert(:direct_note_activity)

	actor = Pleroma.User.get_by_ap_id(note_activity.data["actor"])

	res = Publisher.publish(actor, note_activity)

	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"op" => "publish_one",
	"params" => %{"activity_id" => note_activity.id}
	},
	priority: 0
	)
	end

	test "Publishes with the new actor if prepare_outgoing changes the actor." do
	mock(fn
	%{method: :post, url: "https://domain.com/users/nick1/inbox", body: body} ->
	{:ok, %Tesla.Env{status: 200, body: body}}
	end)

	other_user =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user)
	replaced_actor = insert(:user)

	note_activity =
	insert(:note_activity,
	user: actor,
	data_attrs: %{"to" => [other_user.ap_id]}
	)

	Pleroma.Web.ActivityPub.TransmogrifierMock
	\|> Mox.expect(:prepare_outgoing, fn data ->
	{:ok, Map.put(data, "actor", replaced_actor.ap_id)}
	end)

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: note_activity.id,
	cc: ["https://domain.com/users/nick2/inbox"]
	})

	{:ok, decoded} = Jason.decode(prepared.json)
	assert decoded["actor"] == replaced_actor.ap_id

	{:ok, published} = Publisher.publish_one(prepared)
	sent_activity = Jason.decode!(published.body)
	assert sent_activity["actor"] == replaced_actor.ap_id
	end

	test "publishes an activity with BCC to all relevant peers." do
	follower =
	insert(:user, %{
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	})

	actor = insert(:user, follower_address: follower.ap_id)
	user = insert(:user)

	{:ok, follower, actor} = Pleroma.User.follow(follower, actor)

	note_activity =
	insert(:note_activity,
	recipients: [follower.ap_id],
	data_attrs: %{"bcc" => [user.ap_id]}
	)

	res = Publisher.publish(actor, note_activity)
	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: note_activity.id
	}
	}
	)
	end

	+ test "activity with BCC is published to a list member." do
	+ actor = insert(:user)
	+ {:ok, list} = Pleroma.List.create("list", actor)
	+ list_member = insert(:user, %{local: false})
	+
	+ Pleroma.List.follow(list, list_member)
	+
	+ note_activity =
	+ insert(:note_activity,
	+ # recipients: [follower.ap_id],
	+ data_attrs: %{"bcc" => [list.ap_id]}
	+ )
	+
	+ res = Publisher.publish(actor, note_activity)
	+ assert res == :ok
	+
	+ assert_enqueued(
	+ worker: "Pleroma.Workers.PublisherWorker",
	+ args: %{
	+ "params" => %{
	+ inbox: list_member.inbox,
	+ activity_id: note_activity.id
	+ }
	+ }
	+ )
	+ end
	+
	test "publishes a delete activity to peers who signed fetch requests to the create acitvity/object." do
	fetcher =
	insert(:user,
	local: false,
	inbox: "https://domain.com/users/nick1/inbox"
	)

	another_fetcher =
	insert(:user,
	local: false,
	inbox: "https://domain2.com/users/nick1/inbox"
	)

	actor = insert(:user)

	note_activity = insert(:note_activity, user: actor)
	object = Object.normalize(note_activity, fetch: false)

	activity_path = String.trim_leading(note_activity.data["id"], Pleroma.Web.Endpoint.url())
	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, fetcher)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, another_fetcher)
	\|> get(activity_path)
	\|> json_response(200)

	{:ok, delete} = CommonAPI.delete(note_activity.id, actor)

	res = Publisher.publish(actor, delete)
	assert res == :ok

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain.com/users/nick1/inbox",
	activity_id: delete.id
	}
	},
	priority: 1
	)

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"params" => %{
	inbox: "https://domain2.com/users/nick1/inbox",
	activity_id: delete.id
	}
	},
	priority: 1
	)
	end
	end

	test "cc in prepared json for a follow request is an empty list" do
	user = insert(:user)
	remote_user = insert(:user, local: false)

	{:ok, _, _, activity} = CommonAPI.follow(remote_user, user)

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"activity_id" => activity.id,
	"op" => "publish"
	}
	)

	ObanHelpers.perform_all()

	expected_params =
	%{
	"activity_id" => activity.id,
	"inbox" => remote_user.inbox,
	"unreachable_since" => nil
	}

	assert_enqueued(
	worker: "Pleroma.Workers.PublisherWorker",
	args: %{
	"op" => "publish_one",
	"params" => expected_params
	}
	)

	# params need to be atom keys for Publisher.prepare_one.
	# this is done in the Oban job.
	expected_params = Map.new(expected_params, fn {k, v} -> {String.to_atom(k), v} end)

	%{json: json} = Publisher.prepare_one(expected_params)

	{:ok, decoded} = Jason.decode(json)

	assert decoded["cc"] == []
	end

	test "unlisted activities retain public address in cc" do
	user = insert(:user)

	# simulate unlistd activity by only having
	# public address in cc
	activity =
	insert(:note_activity,
	user: user,
	data_attrs: %{
	"cc" => [@as_public],
	"to" => [user.follower_address]
	}
	)

	assert @as_public in activity.data["cc"]

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://remote.instance/users/someone/inbox",
	activity_id: activity.id
	})

	{:ok, decoded} = Jason.decode(prepared.json)

	assert @as_public in decoded["cc"]

	# maybe we also have another inbox in cc
	# during Publishing
	activity =
	insert(:note_activity,
	user: user,
	data_attrs: %{
	"cc" => [@as_public],
	"to" => [user.follower_address]
	}
	)

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://remote.instance/users/someone/inbox",
	activity_id: activity.id,
	cc: ["https://remote.instance/users/someone_else/inbox"]
	})

	{:ok, decoded} = Jason.decode(prepared.json)

	assert decoded["cc"] == [@as_public, "https://remote.instance/users/someone_else/inbox"]
	end

	test "public address in cc parameter is preserved" do
	user = insert(:user)

	cc_with_public = [@as_public, "https://example.org/users/other"]

	activity =
	insert(:note_activity,
	user: user,
	data_attrs: %{
	"cc" => cc_with_public,
	"to" => [user.follower_address]
	}
	)

	assert @as_public in activity.data["cc"]

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://remote.instance/users/someone/inbox",
	activity_id: activity.id,
	cc: cc_with_public
	})

	{:ok, decoded} = Jason.decode(prepared.json)

	assert cc_with_public == decoded["cc"]
	end

	test "cc parameter is preserved" do
	user = insert(:user)

	activity =
	insert(:note_activity,
	user: user,
	data_attrs: %{
	"cc" => ["https://example.com/specific/user"],
	"to" => [user.follower_address]
	}
	)

	prepared =
	Publisher.prepare_one(%{
	inbox: "https://remote.instance/users/someone/inbox",
	activity_id: activity.id,
	cc: ["https://example.com/specific/user"]
	})

	{:ok, decoded} = Jason.decode(prepared.json)

	assert decoded["cc"] == ["https://example.com/specific/user"]
	end

	describe "prepare_one/1 with reporter anonymization" do
	test "signs with the anonymized actor keys when Transmogrifier changes actor" do
	Pleroma.SignatureMock
	\|> Mox.stub(:signed_date, fn -> Pleroma.Signature.signed_date() end)
	\|> Mox.expect(:sign, fn %Pleroma.User{} = user, _headers ->
	send(self(), {:signed_as, user.ap_id})
	"TESTSIG"
	end)

	placeholder = insert(:user)
	reporter = insert(:user)
	target_account = insert(:user)

	clear_config([:activitypub, :anonymize_reporter], true)
	clear_config([:activitypub, :anonymize_reporter_local_nickname], placeholder.nickname)

	{:ok, reported} = CommonAPI.post(target_account, %{status: "content"})
	context = Utils.generate_context_id()

	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported],
	content: "reason"
	})

	_prepared =
	Publisher.prepare_one(%{
	inbox: "http://remote.example/users/alice/inbox",
	activity_id: activity.id
	})

	assert_received {:signed_as, ap_id}
	assert ap_id == placeholder.ap_id
	end
	end
	end
	diff --git a/test/pleroma/web/feed/user_controller_test.exs b/test/pleroma/web/feed/user_controller_test.exs
	index 0a3aaff5c..916531cd5 100644
	--- a/test/pleroma/web/feed/user_controller_test.exs
	+++ b/test/pleroma/web/feed/user_controller_test.exs
	@@ -1,311 +1,326 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Feed.UserControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import SweetXml

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Feed.FeedView

	setup do: clear_config([:static_fe, :enabled], false)

	describe "feed" do
	setup do: clear_config([:feed])

	setup do
	clear_config(
	[:feed, :post_title],
	%{max_length: 15, omission: "..."}
	)

	activity = insert(:note_activity)

	note =
	insert(:note,
	data: %{
	"content" => "This & this is :moominmamma: note ",
	"source" => "This & this is :moominmamma: note ",
	"attachment" => [
	%{
	"url" => [
	%{"mediaType" => "image/png", "href" => "https://pleroma.gov/image.png"}
	]
	}
	],
	"inReplyTo" => activity.data["id"],
	"context" => "2hu & as",
	"summary" => "2hu & as"
	}
	)

	note_activity = insert(:note_activity, note: note)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	note2 =
	insert(:note,
	user: user,
	data: %{
	"content" => "42 & This is :moominmamma: note ",
	"inReplyTo" => activity.data["id"]
	}
	)

	note_activity2 = insert(:note_activity, note: note2)

	note3 =
	insert(:note,
	user: user,
	data: %{
	"content" => "This note tests whether HTML entities are truncated properly",
	"summary" => "Won't, didn't fail",
	"inReplyTo" => note_activity2.id
	}
	)

	_note_activity3 = insert(:note_activity, note: note3)
	object = Object.normalize(note_activity, fetch: false)

	encoded_title = FeedView.activity_title(note3.data)

	[user: user, object: object, max_id: note_activity2.id, encoded_title: encoded_title]
	end

	test "gets an atom feed", %{conn: conn, user: user, object: object, max_id: max_id} do
	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get("/users/#{user.nickname}/feed", %{"max_id" => max_id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == [~c"2hu & as"]
	end

	test "gets a rss feed", %{conn: conn, user: user, object: object, max_id: max_id} do
	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])

	resp =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss", %{"max_id" => max_id})
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//item/title/text()"l)

	assert activity_titles == [~c"2hu & as"]
	end

	test "returns 404 for a missing feed", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, "nonexisting"))

	assert response(conn, 404)
	end

	test "returns noindex meta for missing user", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("accept", "text/html")
	\|> get("/users/nonexisting")

	assert html_response(conn, 200) =~ "<meta content=\"noindex, noarchive\" name=\"robots\">"
	end

	test "returns feed with public and unlisted activities", %{conn: conn} do
	user = insert(:user)

	{:ok, _} = CommonAPI.post(user, %{status: "public", visibility: "public"})
	{:ok, _} = CommonAPI.post(user, %{status: "direct", visibility: "direct"})
	{:ok, _} = CommonAPI.post(user, %{status: "unlisted", visibility: "unlisted"})
	{:ok, _} = CommonAPI.post(user, %{status: "private", visibility: "private"})

	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)
	\|> Enum.sort()

	assert activity_titles == [~c"public", ~c"unlisted"]
	end

	test "returns 404 when the user is remote", %{conn: conn} do
	user = insert(:user, local: false)

	{:ok, _} = CommonAPI.post(user, %{status: "test"})

	assert conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(404)
	end

	test "does not require authentication on non-federating instances", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/users/#{user.nickname}/feed.rss")
	\|> response(200)
	end

	test "does not mangle HTML entities midway", %{
	conn: conn,
	user: user,
	object: object,
	encoded_title: encoded_title
	} do
	resp =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(200)

	activity_titles =
	resp
	\|> SweetXml.parse()
	\|> SweetXml.xpath(~x"//entry/title/text()"l)

	assert activity_titles == [~c"Won't, didn'...", ~c"2hu", ~c"2hu & as"]
	assert resp =~ FeedView.escape(object.data["content"])
	assert resp =~ FeedView.escape(object.data["summary"])
	assert resp =~ FeedView.escape(object.data["context"])
	assert resp =~ encoded_title
	end
	end

	# Note: see ActivityPubControllerTest for JSON format tests
	describe "feed_redirect" do
	test "with html format, it redirects to user feed", %{conn: conn} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	response =
	conn
	\|> get("/users/#{user.nickname}")
	\|> response(200)

	assert response ==
	Pleroma.Web.Fallback.RedirectController.redirector_with_meta(
	conn,
	%{user: user}
	).resp_body
	end

	test "with html format, it falls back to frontend when user is remote", %{conn: conn} do
	user = insert(:user, local: false)

	{:ok, _} = CommonAPI.post(user, %{status: "test"})

	response =
	conn
	\|> get("/users/#{user.nickname}")
	\|> response(200)

	assert response =~ "</html>"
	end

	test "with html format, it falls back to frontend when user is not found", %{conn: conn} do
	response =
	conn
	\|> get("/users/jimm")
	\|> response(200)

	assert response =~ "</html>"
	end

	test "with non-html / non-json format, it redirects to user feed in atom format", %{
	conn: conn
	} do
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/users/#{user.nickname}")

	assert conn.status == 302

	assert redirected_to(conn) ==
	"#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}/feed.atom"
	end

	+ test "redirects to rss feed when explicitly requested", %{conn: conn} do
	+ note_activity = insert(:note_activity)
	+ user = User.get_cached_by_ap_id(note_activity.data["actor"])
	+
	+ conn =
	+ conn
	+ \|> put_req_header("accept", "application/xml")
	+ \|> get("/users/#{user.nickname}.rss")
	+
	+ assert conn.status == 302
	+
	+ assert redirected_to(conn) ==
	+ "#{Pleroma.Web.Endpoint.url()}/users/#{user.nickname}/feed.rss"
	+ end
	+
	test "with non-html / non-json format, it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get(user_feed_path(conn, :feed, "jimm"))
	\|> response(404)

	assert response == ~S({"error":"Not found"})
	end
	end

	describe "private instance" do
	setup do: clear_config([:instance, :public])

	test "returns 404 for user feed", %{conn: conn} do
	clear_config([:instance, :public], false)
	user = insert(:user)

	{:ok, _} = CommonAPI.post(user, %{status: "test"})

	assert conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(user_feed_path(conn, :feed, user.nickname))
	\|> response(404)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	index 2d91964da..6c277d766 100644
	--- a/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/account_controller_test.exs
	@@ -1,2278 +1,2303 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.Plugs.SetLocalePlug

	import Pleroma.Factory

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	describe "account fetching" do
	test "works by id" do
	%User{id: user_id} = insert(:user)

	assert %{"id" => ^user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user_id}")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "Can't find user"} =
	build_conn()
	\|> get("/api/v1/accounts/-1")
	\|> json_response_and_validate_schema(404)
	end

	test "relationship field" do
	%{conn: conn, user: user} = oauth_access(["read"])

	other_user = insert(:user)

	response =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert response["id"] == other_user.id
	assert response["pleroma"]["relationship"] == %{}

	assert %{"pleroma" => %{"relationship" => %{"following" => false, "followed_by" => false}}} =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, %{id: other_id}} = User.follow(user, other_user)

	assert %{
	"id" => ^other_id,
	"pleroma" => %{"relationship" => %{"following" => true, "followed_by" => false}}
	} =
	conn
	\|> get("/api/v1/accounts/#{other_id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, _} = User.follow(other_user, user)

	assert %{
	"id" => ^other_id,
	"pleroma" => %{"relationship" => %{"following" => true, "followed_by" => true}}
	} =
	conn
	\|> get("/api/v1/accounts/#{other_id}?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "works by nickname" do
	user = insert(:user)

	assert %{"id" => _user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(200)
	end

	test "works by nickname for remote users" do
	clear_config([:instance, :limit_to_local_content], false)

	user = insert(:user, nickname: "user@example.com", local: false)

	assert %{"id" => _user_id} =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(200)
	end

	test "respects limit_to_local_content == :all for remote user nicknames" do
	clear_config([:instance, :limit_to_local_content], :all)

	user = insert(:user, nickname: "user@example.com", local: false)

	assert build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(404)
	end

	test "respects limit_to_local_content == :unauthenticated for remote user nicknames" do
	clear_config([:instance, :limit_to_local_content], :unauthenticated)

	user = insert(:user, nickname: "user@example.com", local: false)
	reading_user = insert(:user)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert json_response_and_validate_schema(conn, 404)

	conn =
	build_conn()
	\|> assign(:user, reading_user)
	\|> assign(:token, insert(:oauth_token, user: reading_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
	assert id == user.id
	end

	test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
	# Need to set an old-style integer ID to reproduce the problem
	# (these are no longer assigned to new accounts but were preserved
	# for existing accounts during the migration to flakeIDs)
	user_one = insert(:user, %{id: 1212})
	user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})

	acc_one =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}")
	\|> json_response_and_validate_schema(:ok)

	acc_two =
	conn
	\|> get("/api/v1/accounts/#{user_two.nickname}")
	\|> json_response_and_validate_schema(:ok)

	acc_three =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}")
	\|> json_response_and_validate_schema(:ok)

	refute acc_one == acc_two
	assert acc_two == acc_three
	end

	test "returns 404 when user is invisible", %{conn: conn} do
	user = insert(:user, %{invisible: true})

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.nickname}")
	\|> json_response_and_validate_schema(404)
	end

	test "returns 404 for internal.fetch actor", %{conn: conn} do
	%User{nickname: "internal.fetch"} = InternalFetchActor.get_actor()

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/internal.fetch")
	\|> json_response_and_validate_schema(404)
	end

	test "returns 404 for deactivated user", %{conn: conn} do
	user = insert(:user, is_active: false)

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.id}")
	\|> json_response_and_validate_schema(:not_found)
	end
	end

	defp local_and_remote_users do
	local = insert(:user)
	remote = insert(:user, local: false)
	{:ok, local: local, remote: remote}
	end

	describe "user fetching with restrict unauthenticated profiles for local and remote" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}")
	\|> json_response_and_validate_schema(:unauthorized)

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user fetching with restrict unauthenticated profiles for local" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "This API requires an authenticated user"
	}

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user fetching with restrict unauthenticated profiles for remote" do
	setup do: local_and_remote_users()

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")

	assert json_response_and_validate_schema(res_conn, :unauthorized) == %{
	"error" => "This API requires an authenticated user"
	}
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}")
	assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
	end
	end

	describe "user timelines" do
	setup do: oauth_access(["read:statuses"])

	test "works with announces that are just addressed to public", %{conn: conn} do
	user = insert(:user, ap_id: "https://honktest/u/test", local: false)
	other_user = insert(:user)

	{:ok, post} = CommonAPI.post(other_user, %{status: "bonkeronk"})

	{:ok, announce, _} =
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => "https://honktest/u/test",
	"id" => "https://honktest/u/test/bonk/1793M7B9MQ48847vdx",
	"object" => post.data["object"],
	"published" => "2019-06-25T19:33:58Z",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"type" => "Announce"
	}
	\|> ActivityPub.persist(local: false)

	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == announce.id
	end

	test "deactivated user", %{conn: conn} do
	user = insert(:user, is_active: false)

	assert %{"error" => "Can't find user"} ==
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(:not_found)
	end

	test "returns 404 when user is invisible", %{conn: conn} do
	user = insert(:user, %{invisible: true})

	assert %{"error" => "Can't find user"} =
	conn
	\|> get("/api/v1/accounts/#{user.id}")
	\|> json_response_and_validate_schema(404)
	end

	test "respects blocks", %{user: user_one, conn: conn} do
	user_two = insert(:user)
	user_three = insert(:user)

	User.block(user_one, user_two)

	{:ok, activity} = CommonAPI.post(user_two, %{status: "User one sux0rz"})
	{:ok, repeat} = CommonAPI.repeat(activity.id, user_three)

	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == activity.id

	# Even a blocked user will deliver the full user timeline, there would be
	# no point in looking at a blocked users timeline otherwise
	assert resp =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == activity.id

	# Third user's timeline includes the repeat when viewed by unauthenticated user
	resp =
	build_conn()
	\|> get("/api/v1/accounts/#{user_three.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == repeat.id

	# When viewing a third user's timeline, the blocked users' statuses will NOT be shown
	resp = get(conn, "/api/v1/accounts/#{user_three.id}/statuses")

	assert [] == json_response_and_validate_schema(resp, 200)
	end

	test "gets users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, _user_three, _user_one} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{status: "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	status: "Hi, @#{user_two.nickname}.",
	visibility: "direct"
	})

	{:ok, private_activity} =
	CommonAPI.post(user_one, %{status: "private", visibility: "private"})

	# TODO!!!
	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> assign(:token, insert(:oauth_token, user: user_two, scopes: ["read:statuses"]))
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id_one}, %{"id" => id_two}] = resp
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> assign(:token, insert(:oauth_token, user: user_three, scopes: ["read:statuses"]))
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id_one}, %{"id" => id_two}] = resp
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "gets local-only statuses for authenticated users", %{user: _user, conn: conn} do
	user_one = insert(:user)

	{:ok, activity} = CommonAPI.post(user_one, %{status: "HI!!!", visibility: "local"})

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => id}] = resp
	assert id == to_string(activity.id)
	end

	test "gets an users media, excludes reblogs", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])
	other_user = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: user.ap_id)

	{:ok, %{id: image_post_id}} = CommonAPI.post(user, %{status: "cofe", media_ids: [media_id]})

	{:ok, %{id: media_id}} = ActivityPub.upload(file, actor: other_user.ap_id)

	{:ok, %{id: other_image_post_id}} =
	CommonAPI.post(other_user, %{status: "cofe2", media_ids: [media_id]})

	{:ok, _announce} = CommonAPI.repeat(other_image_post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_media=true")

	assert [%{"id" => ^image_post_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(build_conn(), "/api/v1/accounts/#{user.id}/statuses?only_media=1")

	assert [%{"id" => ^image_post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "gets a user's statuses without reblogs", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "HI!!!"})
	{:ok, _} = CommonAPI.repeat(post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=true")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_reblogs=1")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "gets only a user's reblogs", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "HI!!!"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(post_id, user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_reblogs=true")
	assert [%{"id" => ^reblog_id}] = json_response_and_validate_schema(conn, 200)

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?only_reblogs=1")
	assert [%{"id" => ^reblog_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "filters user's statuses by a hashtag", %{user: user, conn: conn} do
	{:ok, %{id: post_id}} = CommonAPI.post(user, %{status: "#hashtag"})
	{:ok, _post} = CommonAPI.post(user, %{status: "hashtag"})

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?tagged=hashtag")
	assert [%{"id" => ^post_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "the user views their own timelines and excludes direct messages", %{
	user: user,
	conn: conn
	} do
	{:ok, %{id: public_activity_id}} =
	CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, _direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	conn = get(conn, "/api/v1/accounts/#{user.id}/statuses?exclude_visibilities[]=direct")
	assert [%{"id" => ^public_activity_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "muted reactions", %{user: user, conn: conn} do
	user2 = insert(:user)
	User.mute(user, user2)
	{:ok, activity} = CommonAPI.post(user, %{status: "."})
	{:ok, _} = CommonAPI.react_with_emoji(activity.id, user2, "🎅")

	result =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => []
	}
	}
	] = result

	result =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?with_muted=true")
	\|> json_response_and_validate_schema(200)

	assert [
	%{
	"pleroma" => %{
	"emoji_reactions" => [%{"count" => 1, "me" => false, "name" => "🎅"}]
	}
	}
	] = result
	end

	test "paginates a user's statuses", %{user: user, conn: conn} do
	{:ok, post_1} = CommonAPI.post(user, %{status: "first post"})
	{:ok, post_2} = CommonAPI.post(user, %{status: "second post"})

	response_1 = get(conn, "/api/v1/accounts/#{user.id}/statuses?limit=1")
	assert [res] = json_response_and_validate_schema(response_1, 200)
	assert res["id"] == post_2.id

	response_2 = get(conn, "/api/v1/accounts/#{user.id}/statuses?limit=1&max_id=#{res["id"]}")
	assert [res] = json_response_and_validate_schema(response_2, 200)
	assert res["id"] == post_1.id

	refute response_1 == response_2
	end
	end

	defp local_and_remote_activities(%{local: local, remote: remote}) do
	insert(:note_activity, user: local)
	insert(:note_activity, user: remote, local: false)

	:ok
	end

	describe "statuses with restrict unauthenticated profiles for local and remote" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "statuses with restrict unauthenticated profiles for local" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :local], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{local.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "statuses with restrict unauthenticated profiles for remote" do
	setup do: local_and_remote_users()
	setup :local_and_remote_activities

	setup do: clear_config([:restrict_unauthenticated, :profiles, :remote], true)

	test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	assert %{"error" => "This API requires an authenticated user"} ==
	conn
	\|> get("/api/v1/accounts/#{remote.id}/statuses")
	\|> json_response_and_validate_schema(:unauthorized)
	end

	test "if user is authenticated", %{local: local, remote: remote} do
	%{conn: conn} = oauth_access(["read"])

	res_conn = get(conn, "/api/v1/accounts/#{local.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1

	res_conn = get(conn, "/api/v1/accounts/#{remote.id}/statuses")
	assert length(json_response_and_validate_schema(res_conn, 200)) == 1
	end
	end

	describe "followers" do
	setup do: oauth_access(["read:accounts"])

	test "getting followers", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, %{id: user_id}, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => ^user_id}] = json_response_and_validate_schema(conn, 200)
	end

	test "following with relationship", %{conn: conn, user: user} do
	other_user = insert(:user)
	{:ok, %{id: id}, _} = User.follow(other_user, user)

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{
	"id" => ^id,
	"following" => false,
	"followed_by" => true
	}
	}
	}
	] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?with_relationships=true")
	\|> json_response_and_validate_schema(200)

	{:ok, _, _} = User.follow(user, other_user)

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{
	"id" => ^id,
	"following" => true,
	"followed_by" => true
	}
	}
	}
	] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "getting followers, hide_followers", %{user: user, conn: conn} do
	other_user = insert(:user, hide_followers: true)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{other_user.id}/followers")

	assert [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting followers, hide_followers, same user requesting" do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting followers, pagination", %{user: user, conn: conn} do
	{:ok, %User{id: follower1_id}, _user} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower2_id}, _user} = :user \|> insert() \|> User.follow(user)
	{:ok, %User{id: follower3_id}, _user} = :user \|> insert() \|> User.follow(user)

	assert [%{"id" => ^follower3_id}, %{"id" => ^follower2_id}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1_id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^follower2_id}, %{"id" => ^follower1_id}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3_id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^follower2_id}, %{"id" => ^follower1_id}] =
	conn
	\|> get(
	"/api/v1/accounts/#{user.id}/followers?id=#{user.id}&limit=20&max_id=#{follower3_id}"
	)
	\|> json_response_and_validate_schema(200)

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3_id}")

	assert [%{"id" => ^follower2_id}] = json_response_and_validate_schema(res_conn, 200)

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{follower2_id}/
	assert link_header =~ ~r/max_id=#{follower2_id}/
	end
	end

	describe "following" do
	setup do: oauth_access(["read:accounts"])

	test "getting following", %{user: user, conn: conn} do
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response_and_validate_schema(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "following with relationship", %{conn: conn, user: user} do
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn = get(conn, "/api/v1/accounts/#{user.id}/following?with_relationships=true")

	id = other_user.id

	assert [
	%{
	"id" => ^id,
	"pleroma" => %{
	"relationship" => %{"id" => ^id, "following" => true, "followed_by" => false}
	}
	}
	] = json_response_and_validate_schema(conn, 200)
	end

	test "getting following, hide_follows, other user requesting" do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting following, hide_follows, same user requesting" do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, _other_user} = User.follow(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> assign(:token, insert(:oauth_token, user: user, scopes: ["read:accounts"]))
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting following, pagination", %{user: user, conn: conn} do
	following1 = insert(:user)
	following2 = insert(:user)
	following3 = insert(:user)
	{:ok, _, _} = User.follow(user, following1)
	{:ok, _, _} = User.follow(user, following2)
	{:ok, _, _} = User.follow(user, following3)

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response_and_validate_schema(res_conn, 200)
	assert id3 == following3.id
	assert id2 == following2.id

	res_conn = get(conn, "/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	get(
	conn,
	"/api/v1/accounts/#{user.id}/following?id=#{user.id}&limit=20&max_id=#{following3.id}"
	)

	assert [%{"id" => id2}, %{"id" => id1}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	get(conn, "/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")

	assert [%{"id" => id2}] = json_response_and_validate_schema(res_conn, 200)
	assert id2 == following2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{following2.id}/
	assert link_header =~ ~r/max_id=#{following2.id}/
	end
	end

	describe "follow/unfollow" do
	setup do: oauth_access(["follow"])

	test "following / unfollowing a user", %{conn: conn} do
	%{id: other_user_id, nickname: other_user_nickname} = insert(:user)

	assert %{"id" => _id, "following" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/follow")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => _id, "following" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/unfollow")
	\|> json_response_and_validate_schema(200)

	assert %{"id" => ^other_user_id} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/follows", %{"uri" => other_user_nickname})
	\|> json_response_and_validate_schema(200)
	end

	test "cancelling follow request", %{conn: conn} do
	%{id: other_user_id} = insert(:user, %{is_locked: true})

	assert %{"id" => ^other_user_id, "following" => false, "requested" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/follow")
	\|> json_response_and_validate_schema(:ok)

	assert %{"id" => ^other_user_id, "following" => false, "requested" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/unfollow")
	\|> json_response_and_validate_schema(:ok)
	end

	test "following without reblogs" do
	%{conn: conn} = oauth_access(["follow", "read:statuses"])
	followed = insert(:user)
	other_user = insert(:user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: false})

	assert %{"showing_reblogs" => false} = json_response_and_validate_schema(ret_conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(activity.id, followed)

	assert [] ==
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: true})
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: "1"})
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^reblog_id}] =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)
	end

	test "following with reblogs" do
	%{conn: conn} = oauth_access(["follow", "read:statuses"])
	followed = insert(:user)
	other_user = insert(:user)

	ret_conn = post(conn, "/api/v1/accounts/#{followed.id}/follow")

	assert %{"showing_reblogs" => true} = json_response_and_validate_schema(ret_conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
	{:ok, %{id: reblog_id}} = CommonAPI.repeat(activity.id, followed)

	assert [%{"id" => ^reblog_id}] =
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: false})
	\|> json_response_and_validate_schema(200)

	assert %{"showing_reblogs" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{reblogs: "0"})
	\|> json_response_and_validate_schema(200)

	assert [] ==
	conn
	\|> get("/api/v1/timelines/home")
	\|> json_response_and_validate_schema(200)
	end

	test "following with subscription and unsubscribing" do
	%{conn: conn} = oauth_access(["follow"])
	followed = insert(:user)

	assert %{"subscribing" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: true})
	\|> json_response_and_validate_schema(200)

	assert %{"subscribing" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: "1"})
	\|> json_response_and_validate_schema(200)

	assert %{"subscribing" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{followed.id}/follow", %{notify: false})
	\|> json_response_and_validate_schema(200)
	end

	test "following / unfollowing errors", %{user: user, conn: conn} do
	# self follow
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/follow")

	assert %{"error" => "Can not follow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# self unfollow
	user = User.get_cached_by_id(user.id)
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/unfollow")

	assert %{"error" => "Can not unfollow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# self follow via uri
	user = User.get_cached_by_id(user.id)

	assert %{"error" => "Can not follow yourself"} =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/follows", %{"uri" => user.nickname})
	\|> json_response_and_validate_schema(400)

	# follow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/follow")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)

	# follow non existing user via uri
	conn_res =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/follows", %{"uri" => "doesntexist"})

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)

	# unfollow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/unfollow")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)
	end
	end

	describe "mute/unmute" do
	setup do: oauth_access(["write:mutes"])

	test "with notifications", %{conn: conn} do
	other_user = insert(:user)

	assert %{"id" => _id, "muting" => true, "muting_notifications" => true} =
	conn
	\|> post("/api/v1/accounts/#{other_user.id}/mute")
	\|> json_response_and_validate_schema(200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} =
	json_response_and_validate_schema(conn, 200)
	end

	test "without notifications", %{conn: conn} do
	other_user = insert(:user)

	ret_conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"notifications" => "false"})

	assert %{"id" => _id, "muting" => true, "muting_notifications" => false} =
	json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} =
	json_response_and_validate_schema(conn, 200)
	end

	test "expiring", %{conn: conn, user: user} do
	other_user = insert(:user)

	conn =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"duration" => "86400"})

	assert %{"id" => _id, "muting" => true} = json_response_and_validate_schema(conn, 200)

	mute_expires_at = UserRelationship.get_mute_expire_date(user, other_user)

	assert DateTime.diff(
	mute_expires_at,
	DateTime.utc_now() \|> DateTime.add(24 * 60 * 60)
	) in -3..3
	end

	test "falls back to expires_in", %{conn: conn, user: user} do
	other_user = insert(:user)

	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"expires_in" => "86400"})
	\|> json_response_and_validate_schema(200)

	mute_expires_at = UserRelationship.get_mute_expire_date(user, other_user)

	assert DateTime.diff(
	mute_expires_at,
	DateTime.utc_now() \|> DateTime.add(24 * 60 * 60)
	) in -3..3
	end
	end

	describe "pinned statuses" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
	%{conn: conn} = oauth_access(["read:statuses"], user: user)

	[conn: conn, user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: %{id: activity_id}} do
	{:ok, _} = CommonAPI.pin(activity_id, user)

	assert [%{"id" => ^activity_id, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end
	end

	test "view pinned private statuses" do
	user = insert(:user)
	reader = insert(:user)

	# Create a private status and pin it
	{:ok, %{id: activity_id} = activity} =
	CommonAPI.post(user, %{status: "psst", visibility: "private"})

	%{data: %{"id" => object_ap_id}} = Object.normalize(activity)
	{:ok, _} = User.add_pinned_object_id(user, object_ap_id)

	%{conn: conn} = oauth_access(["read:statuses"], user: reader)

	# A non-follower can't see the pinned status
	assert [] ==
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)

	# Follow the user, then the pinned status can be seen
	CommonAPI.follow(user, reader)
	ObanHelpers.perform_all()

	assert [%{"id" => ^activity_id, "pinned" => true}] =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response_and_validate_schema(200)
	end

	test "blocking / unblocking a user" do
	%{conn: conn} = oauth_access(["follow"])
	other_user = insert(:user)

	ret_conn = post(conn, "/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response_and_validate_schema(conn, 200)
	end

	describe "create account by app" do
	setup do
	valid_params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	}

	[valid_params: valid_params]
	end

	test "registers and logs in without :account_activation_required / :account_approval_required",
	%{conn: conn} do
	clear_config([:instance, :account_activation_required], false)
	clear_config([:instance, :account_approval_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: client_secret
	})

	assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	json_response(conn, 200)

	assert token
	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	assert refresh
	assert scope == "read write follow"

	clear_config([User, :email_blacklist], ["example.org"])

	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true
	}

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", params)

	assert %{"error" => "{\"email\":[\"Invalid email\"]}"} =
	json_response_and_validate_schema(conn, 400)

	clear_config([User, :email_blacklist], [])

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", params)

	%{
	"access_token" => token,
	"created_at" => _created_at,
	"scope" => ^scope,
	"token_type" => "Bearer"
	} = json_response_and_validate_schema(conn, 200)

	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	user = Repo.preload(token_from_db, :user).user

	assert user
	assert user.is_confirmed
	assert user.is_approved
	end

	test "registers but does not log in with :account_activation_required", %{conn: conn} do
	clear_config([:instance, :account_activation_required], true)
	clear_config([:instance, :account_approval_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: client_secret
	})

	assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	json_response(conn, 200)

	assert token
	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	assert refresh
	assert scope == "read write follow"

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true
	})

	response = json_response_and_validate_schema(conn, 200)
	assert %{"identifier" => "missing_confirmed_email"} = response
	refute response["access_token"]
	refute response["token_type"]

	user = Repo.get_by(User, email: "lain@example.org")
	refute user.is_confirmed
	end

	test "registers but does not log in with :account_approval_required", %{conn: conn} do
	clear_config([:instance, :account_approval_required], true)
	clear_config([:instance, :account_activation_required], false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	assert %{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response_and_validate_schema(conn, 200)

	conn =
	post(conn, "/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: client_secret
	})

	assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	json_response(conn, 200)

	assert token
	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	assert refresh
	assert scope == "read write follow"

	conn =
	build_conn()
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	bio: "Test Bio",
	agreement: true,
	reason: "I'm a cool dude, bro"
	})

	response = json_response_and_validate_schema(conn, 200)
	assert %{"identifier" => "awaiting_approval"} = response
	refute response["access_token"]
	refute response["token_type"]

	user = Repo.get_by(User, email: "lain@example.org")

	refute user.is_approved
	assert user.registration_reason == "I'm a cool dude, bro"
	end

	test "returns error when user already registered", %{conn: conn, valid_params: valid_params} do
	_user = insert(:user, email: "lain@example.org")
	app_token = insert(:oauth_token, user: nil)

	res =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts", valid_params)

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"email\":[\"has already been taken\"]}"
	}
	end

	test "returns bad_request if missing required params", %{
	conn: conn,
	valid_params: valid_params
	} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")

	res = post(conn, "/api/v1/accounts", valid_params)
	assert json_response_and_validate_schema(res, 200)

	[{127, 0, 0, 1}, {127, 0, 0, 2}, {127, 0, 0, 3}, {127, 0, 0, 4}]
	\|> Stream.zip(Map.delete(valid_params, :email))
	\|> Enum.each(fn {ip, {attr, _}} ->
	res =
	conn
	\|> Map.put(:remote_ip, ip)
	\|> post("/api/v1/accounts", Map.delete(valid_params, attr))
	\|> json_response_and_validate_schema(400)

	assert res == %{
	"error" => "Missing field: #{attr}.",
	"errors" => [
	%{
	"message" => "Missing field: #{attr}",
	"source" => %{"pointer" => "/#{attr}"},
	"title" => "Invalid value"
	}
	]
	}
	end)
	end

	test "returns bad_request if missing email params when :account_activation_required is enabled",
	%{conn: conn, valid_params: valid_params} do
	clear_config([:instance, :account_activation_required], true)

	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "application/json")

	res =
	conn
	\|> Map.put(:remote_ip, {127, 0, 0, 5})
	\|> post("/api/v1/accounts", Map.delete(valid_params, :email))

	assert json_response_and_validate_schema(res, 400) ==
	%{"error" => "Missing parameter: email"}

	res =
	conn
	\|> Map.put(:remote_ip, {127, 0, 0, 6})
	\|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"email\":[\"can't be blank\"]}"
	}
	end

	test "allow registration without an email", %{conn: conn, valid_params: valid_params} do
	app_token = insert(:oauth_token, user: nil)
	conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)

	res =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> Map.put(:remote_ip, {127, 0, 0, 7})
	\|> post("/api/v1/accounts", Map.delete(valid_params, :email))

	assert json_response_and_validate_schema(res, 200)
	end

	test "allow registration with an empty email", %{conn: conn, valid_params: valid_params} do
	app_token = insert(:oauth_token, user: nil)
	conn = put_req_header(conn, "authorization", "Bearer " <> app_token.token)

	res =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> Map.put(:remote_ip, {127, 0, 0, 8})
	\|> post("/api/v1/accounts", Map.put(valid_params, :email, ""))

	assert json_response_and_validate_schema(res, 200)
	end

	test "returns forbidden if token is invalid", %{conn: conn, valid_params: valid_params} do
	res =
	conn
	\|> put_req_header("authorization", "Bearer " <> "invalid-token")
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts", valid_params)

	assert json_response_and_validate_schema(res, 403) == %{"error" => "Invalid credentials"}
	end

	test "registration from trusted app" do
	clear_config([Pleroma.Captcha, :enabled], true)
	app = insert(:oauth_app, trusted: true, scopes: ["read", "write", "follow", "push"])

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "client_credentials",
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token, "token_type" => "Bearer"} = json_response(conn, 200)

	response =
	build_conn()
	\|> Plug.Conn.put_req_header("authorization", "Bearer " <> token)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/accounts", %{
	nickname: "nickname",
	agreement: true,
	email: "email@example.com",
	fullname: "Lain",
	username: "Lain",
	password: "some_password",
	confirm: "some_password"
	})
	\|> json_response_and_validate_schema(200)

	assert %{
	"access_token" => access_token,
	"created_at" => _,
	"scope" => "read write follow push",
	"token_type" => "Bearer"
	} = response

	response =
	build_conn()
	\|> Plug.Conn.put_req_header("authorization", "Bearer " <> access_token)
	\|> get("/api/v1/accounts/verify_credentials")
	\|> json_response_and_validate_schema(200)

	assert %{
	"acct" => "Lain",
	"bot" => false,
	"display_name" => "Lain",
	"follow_requests_count" => 0,
	"followers_count" => 0,
	"following_count" => 0,
	"locked" => false,
	"note" => "",
	"source" => %{
	"fields" => [],
	"note" => "",
	"pleroma" => %{
	"actor_type" => "Person",
	"discoverable" => false,
	"no_rich_text" => false,
	"show_role" => true
	},
	"privacy" => "public",
	"sensitive" => false
	},
	"statuses_count" => 0,
	"username" => "Lain"
	} = response
	end
	end

	describe "create account by app / rate limit" do
	setup do: clear_config([:rate_limit, :app_account_creation], {10_000, 2})

	test "respects rate limit setting", %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> Map.put(:remote_ip, {15, 15, 15, 15})
	\|> put_req_header("content-type", "multipart/form-data")

	for i <- 1..2 do
	conn =
	conn
	\|> post("/api/v1/accounts", %{
	username: "#{i}lain",
	email: "#{i}lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	%{
	"access_token" => token,
	"created_at" => _created_at,
	"scope" => _scope,
	"token_type" => "Bearer"
	} = json_response_and_validate_schema(conn, 200)

	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	token_from_db = Repo.preload(token_from_db, :user)
	assert token_from_db.user
	end

	conn =
	post(conn, "/api/v1/accounts", %{
	username: "6lain",
	email: "6lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	assert json_response_and_validate_schema(conn, :too_many_requests) == %{
	"error" => "Throttled"
	}
	end
	end

	describe "create account with enabled captcha" do
	setup %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")

	[conn: conn]
	end

	setup do: clear_config([Pleroma.Captcha, :enabled], true)

	test "creates an account and returns 200 if captcha is valid", %{conn: conn} do
	%{token: token, answer_data: answer_data} = Pleroma.Captcha.new()

	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: Pleroma.Captcha.Mock.solution(),
	captcha_token: token,
	captcha_answer_data: answer_data
	}

	assert %{
	"access_token" => access_token,
	"created_at" => _,
	"scope" => "read",
	"token_type" => "Bearer"
	} =
	conn
	\|> post("/api/v1/accounts", params)
	\|> json_response_and_validate_schema(:ok)

	assert Token \|> Repo.get_by(token: access_token) \|> Repo.preload(:user) \|> Map.get(:user)
	end

	test "returns 400 if any captcha field is not provided", %{conn: conn} do
	captcha_fields = [:captcha_solution, :captcha_token, :captcha_answer_data]

	valid_params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: "xx",
	captcha_token: "xx",
	captcha_answer_data: "xx"
	}

	for field <- captcha_fields do
	expected = %{
	"error" => "{\"captcha\":[\"Invalid CAPTCHA (Missing parameter: #{field})\"]}"
	}

	assert expected ==
	conn
	\|> post("/api/v1/accounts", Map.delete(valid_params, field))
	\|> json_response_and_validate_schema(:bad_request)
	end
	end

	test "returns an error if captcha is invalid", %{conn: conn} do
	params = %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true,
	captcha_solution: "cofe",
	captcha_token: "cofe",
	captcha_answer_data: "cofe"
	}

	assert %{"error" => "{\"captcha\":[\"Invalid answer data\"]}"} ==
	conn
	\|> post("/api/v1/accounts", params)
	\|> json_response_and_validate_schema(:bad_request)
	end
	end

	describe "create account with required birth date" do
	setup %{conn: conn} do
	clear_config([:instance, :birthday_required], true)
	clear_config([:instance, :birthday_min_age], 18 * 365)

	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")

	[conn: conn]
	end

	test "creates an account if provided valid birth date", %{conn: conn} do
	birthday =
	Date.utc_today()
	\|> Date.add(-19 * 365)
	\|> Date.to_string()

	params = %{
	username: "mkljczk",
	email: "mkljczk@example.org",
	password: "dupa.8",
	agreement: true,
	birthday: birthday
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)
	end

	test "returns an error if missing birth date", %{conn: conn} do
	params = %{
	username: "mkljczk",
	email: "mkljczk@example.org",
	password: "dupa.8",
	agreement: true
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 400) == %{
	"error" => "{\"birthday\":[\"can't be blank\"]}"
	}
	end
	end

	describe "create account with language" do
	setup %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	conn
	\|> put_req_header("authorization", "Bearer " <> app_token.token)
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put_req_cookie(SetLocalePlug.frontend_language_cookie_name(), "zh-Hans")
	\|> SetLocalePlug.call([])

	[conn: conn]
	end

	test "creates an account with language parameter", %{conn: conn} do
	params = %{
	username: "foo",
	email: "foo@example.org",
	password: "dupa.8",
	agreement: true,
	language: "ru"
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "ru"} = Pleroma.User.get_by_nickname("foo")
	end

	test "language parameter should be normalized", %{conn: conn} do
	params = %{
	username: "foo",
	email: "foo@example.org",
	password: "dupa.8",
	agreement: true,
	language: "ru-RU"
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "ru_RU"} = Pleroma.User.get_by_nickname("foo")
	end

	test "creating an account without language parameter should fallback to cookie/header language",
	%{conn: conn} do
	params = %{
	username: "foo2",
	email: "foo2@example.org",
	password: "dupa.8",
	agreement: true
	}

	res =
	conn
	\|> post("/api/v1/accounts", params)

	assert json_response_and_validate_schema(res, 200)

	assert %{language: "zh_Hans"} = Pleroma.User.get_by_nickname("foo2")
	end
	end

	describe "GET /api/v1/accounts/:id/lists - account_lists" do
	test "returns lists to which the account belongs" do
	%{user: user, conn: conn} = oauth_access(["read:lists"])
	other_user = insert(:user)
	assert {:ok, %Pleroma.List{id: _list_id} = list} = Pleroma.List.create("Test List", user)
	{:ok, %{following: _following}} = Pleroma.List.follow(list, other_user)

	assert [%{"id" => _list_id, "title" => "Test List"}] =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/lists")
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "verify_credentials" do
	test "verify_credentials" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	[notification \| _] =
	insert_list(7, :notification, user: user, activity: insert(:note_activity))

	Pleroma.Notification.set_read_up_to(user, notification.id)
	conn = get(conn, "/api/v1/accounts/verify_credentials")

	response = json_response_and_validate_schema(conn, 200)

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = response
	assert response["pleroma"]["chat_token"]
	assert response["pleroma"]["unread_notifications_count"] == 6
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted" do
	user = insert(:user, default_scope: "unlisted")
	%{conn: conn} = oauth_access(["read:accounts"], user: user)

	conn = get(conn, "/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} =
	json_response_and_validate_schema(conn, 200)

	assert id == to_string(user.id)
	end

	test "locked accounts" do
	user = insert(:user, default_scope: "private")
	%{conn: conn} = oauth_access(["read:accounts"], user: user)

	conn = get(conn, "/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} =
	json_response_and_validate_schema(conn, 200)

	assert id == to_string(user.id)
	end
	end

	describe "user relationships" do
	setup do: oauth_access(["read:follows"])

	test "returns the relationships for the current user", %{user: user, conn: conn} do
	%{id: other_user_id} = other_user = insert(:user)
	{:ok, _user, _other_user} = User.follow(user, other_user)

	assert [%{"id" => ^other_user_id}] =
	conn
	\|> get("/api/v1/accounts/relationships?id=#{other_user.id}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^other_user_id}] =
	conn
	\|> get("/api/v1/accounts/relationships?id[]=#{other_user.id}")
	\|> json_response_and_validate_schema(200)
	end

	test "returns an empty list on a bad request", %{conn: conn} do
	conn = get(conn, "/api/v1/accounts/relationships", %{})

	assert [] = json_response_and_validate_schema(conn, 200)
	end
	end

	test "getting a list of mutes" do
	%{user: user, conn: conn} = oauth_access(["read:mutes"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _user_relationships} = User.mute(user, other_user1)
	{:ok, _user_relationships} = User.mute(user, other_user2)
	{:ok, _user_relationships} = User.mute(user, other_user3)

	result =
	conn
	\|> get("/api/v1/mutes")
	\|> json_response_and_validate_schema(200)

	assert [id3, id2, id1] == Enum.map(result, & &1["id"])

	result =
	conn
	\|> get("/api/v1/mutes?limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}&max_id=#{id3}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result

	result =
	conn
	\|> get("/api/v1/mutes?since_id=#{id1}&limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result
	end

	test "list of mutes with with_relationships parameter" do
	%{user: user, conn: conn} = oauth_access(["read:mutes"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _, _} = User.follow(other_user1, user)
	{:ok, _, _} = User.follow(other_user2, user)
	{:ok, _, _} = User.follow(other_user3, user)

	{:ok, _} = User.mute(user, other_user1)
	{:ok, _} = User.mute(user, other_user2)
	{:ok, _} = User.mute(user, other_user3)

	assert [
	%{
	"id" => ^id3,
	"pleroma" => %{"relationship" => %{"muting" => true, "followed_by" => true}}
	},
	%{
	"id" => ^id2,
	"pleroma" => %{"relationship" => %{"muting" => true, "followed_by" => true}}
	},
	%{
	"id" => ^id1,
	"pleroma" => %{"relationship" => %{"muting" => true, "followed_by" => true}}
	}
	] =
	conn
	\|> get("/api/v1/mutes?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "getting a list of blocks" do
	%{user: user, conn: conn} = oauth_access(["read:blocks"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _user_relationship} = User.block(user, other_user1)
	{:ok, _user_relationship} = User.block(user, other_user3)
	{:ok, _user_relationship} = User.block(user, other_user2)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")
	\|> json_response_and_validate_schema(200)

	assert [id3, id2, id1] == Enum.map(result, & &1["id"])

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}&max_id=#{id3}")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?since_id=#{id1}&limit=1")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}] = result

	conn_res =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks?limit=2")

	next_url =
	~r{<.+?(?<link>/api[^>]+)>; rel=\"next\"}
	\|> Regex.named_captures(get_resp_header(conn_res, "link") \|> Enum.at(0))
	\|> Map.get("link")

	result =
	conn_res
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id3}, %{"id" => ^id2}] = result

	result =
	conn
	\|> assign(:user, user)
	\|> get(next_url)
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id1}] = result
	end

	test "list of blocks with with_relationships parameter" do
	%{user: user, conn: conn} = oauth_access(["read:blocks"])
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	%{id: id3} = other_user3 = insert(:user)

	{:ok, _, _} = User.follow(other_user1, user)
	{:ok, _, _} = User.follow(other_user2, user)
	{:ok, _, _} = User.follow(other_user3, user)

	{:ok, _} = User.block(user, other_user1)
	{:ok, _} = User.block(user, other_user2)
	{:ok, _} = User.block(user, other_user3)

	assert [
	%{
	"id" => ^id3,
	"pleroma" => %{"relationship" => %{"blocking" => true, "followed_by" => false}}
	},
	%{
	"id" => ^id2,
	"pleroma" => %{"relationship" => %{"blocking" => true, "followed_by" => false}}
	},
	%{
	"id" => ^id1,
	"pleroma" => %{"relationship" => %{"blocking" => true, "followed_by" => false}}
	}
	] =
	conn
	\|> get("/api/v1/blocks?with_relationships=true")
	\|> json_response_and_validate_schema(200)
	end

	test "account lookup", %{conn: conn} do
	%{nickname: acct} = insert(:user, %{nickname: "nickname"})
	%{nickname: acct_two} = insert(:user, %{nickname: "nickname@notlocaldoma.in"})

	result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=#{acct}")
	\|> json_response_and_validate_schema(200)

	assert %{"acct" => ^acct} = result

	result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=#{acct_two}")
	\|> json_response_and_validate_schema(200)

	assert %{"acct" => ^acct_two} = result

	_result =
	conn
	\|> get("/api/v1/accounts/lookup?acct=unexisting_nickname")
	\|> json_response_and_validate_schema(404)
	end

	test "create a note on a user" do
	%{conn: conn} = oauth_access(["write:accounts", "read:follows"])
	other_user = insert(:user)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/accounts/#{other_user.id}/note", %{
	"comment" => "Example note"
	})

	assert [%{"note" => "Example note"}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/relationships?id=#{other_user.id}")
	\|> json_response_and_validate_schema(200)
	end

	describe "account endorsements" do
	setup do: oauth_access(["read:accounts", "write:accounts", "write:follows"])

	setup do: clear_config([:instance, :max_endorsed_users], 1)

	test "pin account", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)

	CommonAPI.follow(other_user1, user)

	assert %{"id" => ^id1, "endorsed" => true} =
	conn
	\|> put_req_header("content-type", "application/json")
	- \|> post("/api/v1/accounts/#{id1}/pin")
	+ \|> post("/api/v1/accounts/#{id1}/endorse")
	\|> json_response_and_validate_schema(200)

	assert [%{"id" => ^id1}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/endorsements")
	\|> json_response_and_validate_schema(200)
	end

	test "unpin account", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)

	CommonAPI.follow(other_user1, user)
	User.endorse(user, other_user1)

	assert %{"id" => ^id1, "endorsed" => false} =
	conn
	\|> put_req_header("content-type", "application/json")
	- \|> post("/api/v1/accounts/#{id1}/unpin")
	+ \|> post("/api/v1/accounts/#{id1}/unendorse")
	\|> json_response_and_validate_schema(200)

	assert [] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/endorsements")
	\|> json_response_and_validate_schema(200)
	end

	test "max pinned accounts", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)

	CommonAPI.follow(other_user1, user)
	CommonAPI.follow(other_user2, user)

	conn
	\|> put_req_header("content-type", "application/json")
	- \|> post("/api/v1/accounts/#{id1}/pin")
	+ \|> post("/api/v1/accounts/#{id1}/endorse")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "You have already pinned the maximum number of users"} =
	conn
	\|> assign(:user, user)
	- \|> post("/api/v1/accounts/#{id2}/pin")
	+ \|> post("/api/v1/accounts/#{id2}/endorse")
	\|> json_response_and_validate_schema(400)
	end
	+
	+ test "returns a list of pinned accounts", %{conn: conn} do
	+ clear_config([:instance, :max_endorsed_users], 3)
	+
	+ %{id: id1} = user1 = insert(:user)
	+ %{id: id2} = user2 = insert(:user)
	+ %{id: id3} = user3 = insert(:user)
	+
	+ CommonAPI.follow(user2, user1)
	+ CommonAPI.follow(user3, user1)
	+
	+ User.endorse(user1, user2)
	+ User.endorse(user1, user3)
	+
	+ [%{"id" => ^id2}, %{"id" => ^id3}] =
	+ conn
	+ \|> get("/api/v1/accounts/#{id1}/endorsements")
	+ \|> json_response_and_validate_schema(200)
	+ end
	+
	+ test "returns 404 error when specified user is not exist", %{conn: conn} do
	+ conn = get(conn, "/api/v1/accounts/test/endorsements")
	+
	+ assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	+ end
	end

	describe "familiar followers" do
	setup do: oauth_access(["read:follows"])

	test "fetch user familiar followers", %{user: user, conn: conn} do
	%{id: id1} = other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [%{"id" => ^id1}], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end

	test "returns empty array if followers are hidden", %{user: user, conn: conn} do
	other_user1 = insert(:user, hide_follows: true)
	%{id: id2} = other_user2 = insert(:user)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end

	test "it respects hide_followers", %{user: user, conn: conn} do
	other_user1 = insert(:user)
	%{id: id2} = other_user2 = insert(:user, hide_followers: true)
	_ = insert(:user)

	User.follow(user, other_user1)
	User.follow(other_user1, other_user2)

	assert [%{"accounts" => [], "id" => ^id2}] =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
	\|> json_response_and_validate_schema(200)
	end
	end

	describe "remove from followers" do
	setup do: oauth_access(["follow"])

	test "removing user from followers", %{conn: conn, user: user} do
	%{id: other_user_id} = other_user = insert(:user)

	CommonAPI.follow(user, other_user)

	assert %{"id" => ^other_user_id, "followed_by" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/remove_from_followers")
	\|> json_response_and_validate_schema(200)

	refute User.following?(other_user, user)
	end

	test "removing remote user from followers", %{conn: conn, user: user} do
	%{id: other_user_id} = other_user = insert(:user, local: false)

	CommonAPI.follow(user, other_user)

	assert User.following?(other_user, user)

	assert %{"id" => ^other_user_id, "followed_by" => false} =
	conn
	\|> post("/api/v1/accounts/#{other_user_id}/remove_from_followers")
	\|> json_response_and_validate_schema(200)

	refute User.following?(other_user, user)
	end

	test "removing user from followers errors", %{user: user, conn: conn} do
	# self remove
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/remove_from_followers")

	assert %{"error" => "Can not unfollow yourself"} =
	json_response_and_validate_schema(conn_res, 400)

	# remove non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/remove_from_followers")
	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn_res, 404)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	index 8a0fe5259..10c0b6ea7 100644
	--- a/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/instance_controller_test.exs
	@@ -1,197 +1,221 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.InstanceControllerTest do
	# TODO: Should not need Cachex
	use Pleroma.Web.ConnCase

	alias Pleroma.Rule
	alias Pleroma.User
	import Pleroma.Factory

	test "get instance information", %{conn: conn} do
	conn = get(conn, "/api/v1/instance")
	assert result = json_response_and_validate_schema(conn, 200)

	email = Pleroma.Config.get([:instance, :email])
	thumbnail = Pleroma.Web.Endpoint.url() <> Pleroma.Config.get([:instance, :instance_thumbnail])
	background = Pleroma.Web.Endpoint.url() <> Pleroma.Config.get([:instance, :background_image])

	# Note: not checking for "max_toot_chars" since it's optional
	assert %{
	"uri" => _,
	"title" => _,
	"description" => _,
	"short_description" => _,
	"version" => _,
	"email" => from_config_email,
	"urls" => %{
	"streaming_api" => _
	},
	"stats" => _,
	"thumbnail" => from_config_thumbnail,
	"languages" => _,
	"registrations" => _,
	"approval_required" => _,
	"poll_limits" => _,
	"upload_limit" => _,
	"avatar_upload_limit" => _,
	"background_upload_limit" => _,
	"banner_upload_limit" => _,
	"background_image" => from_config_background,
	"shout_limit" => _,
	"description_limit" => _,
	"rules" => _
	} = result

	assert result["pleroma"]["metadata"]["account_activation_required"] != nil
	assert result["pleroma"]["metadata"]["features"]
	assert result["pleroma"]["metadata"]["federation"]
	assert result["pleroma"]["metadata"]["fields_limits"]
	assert result["pleroma"]["vapid_public_key"]
	assert result["pleroma"]["stats"]["mau"] == 0

	assert email == from_config_email
	assert thumbnail == from_config_thumbnail
	assert background == from_config_background
	end

	test "get instance stats", %{conn: conn} do
	user = insert(:user, %{local: true})

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.set_activation(user2, false)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = Pleroma.Web.CommonAPI.post(user, %{status: "cofe"})

	Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance")

	assert result = json_response_and_validate_schema(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response_and_validate_schema(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end

	test "instance languages", %{conn: conn} do
	assert %{"languages" => ["en"]} =
	conn
	\|> get("/api/v1/instance")
	\|> json_response_and_validate_schema(200)

	clear_config([:instance, :languages], ["aa", "bb"])

	assert %{"languages" => ["aa", "bb"]} =
	conn
	\|> get("/api/v1/instance")
	\|> json_response_and_validate_schema(200)
	end

	test "get instance contact information", %{conn: conn} do
	user = insert(:user, %{local: true})

	clear_config([:instance, :contact_username], user.nickname)

	conn = get(conn, "/api/v1/instance")

	assert result = json_response_and_validate_schema(conn, 200)

	assert result["contact_account"]["id"] == user.id
	end

	test "get instance information v2", %{conn: conn} do
	clear_config([:auth, :oauth_consumer_strategies], [])

	assert get(conn, "/api/v2/instance")
	\|> json_response_and_validate_schema(200)
	end

	test "get instance rules", %{conn: conn} do
	Rule.create(%{text: "Example rule", hint: "Rule description", priority: 1})
	Rule.create(%{text: "Third rule", priority: 2})
	Rule.create(%{text: "Second rule", priority: 1})

	conn = get(conn, "/api/v1/instance")

	assert result = json_response_and_validate_schema(conn, 200)

	assert [
	%{
	"text" => "Example rule",
	"hint" => "Rule description"
	},
	%{
	"text" => "Second rule",
	"hint" => ""
	},
	%{
	"text" => "Third rule",
	"hint" => ""
	}
	] = result["rules"]
	end

	test "translation languages matrix", %{conn: conn} do
	clear_config([Pleroma.Language.Translation, :provider], TranslationMock)

	assert %{"en" => ["pl"], "pl" => ["en"]} =
	conn
	\|> get("/api/v1/instance/translation_languages")
	\|> json_response_and_validate_schema(200)
	end

	test "base_urls in pleroma metadata", %{conn: conn} do
	media_proxy_base_url = "https://media.example.org"
	upload_base_url = "https://uploads.example.org"

	clear_config([:media_proxy, :enabled], true)
	clear_config([:media_proxy, :base_url], media_proxy_base_url)
	clear_config([Pleroma.Upload, :base_url], upload_base_url)

	conn = get(conn, "/api/v1/instance")

	assert result = json_response_and_validate_schema(conn, 200)
	assert result["pleroma"]["metadata"]["base_urls"]["media_proxy"] == media_proxy_base_url
	assert result["pleroma"]["metadata"]["base_urls"]["upload"] == upload_base_url

	# Test when media_proxy is disabled
	clear_config([:media_proxy, :enabled], false)

	conn = get(conn, "/api/v1/instance")

	assert result = json_response_and_validate_schema(conn, 200)
	refute Map.has_key?(result["pleroma"]["metadata"]["base_urls"], "media_proxy")
	assert result["pleroma"]["metadata"]["base_urls"]["upload"] == upload_base_url

	# Test when upload base_url is not set
	clear_config([Pleroma.Upload, :base_url], nil)

	conn = get(conn, "/api/v1/instance")

	assert result = json_response_and_validate_schema(conn, 200)
	refute Map.has_key?(result["pleroma"]["metadata"]["base_urls"], "media_proxy")
	refute Map.has_key?(result["pleroma"]["metadata"]["base_urls"], "upload")
	end
	+
	+ test "display timeline access restrictions", %{conn: conn} do
	+ clear_config([:restrict_unauthenticated, :timelines, :local], true)
	+ clear_config([:restrict_unauthenticated, :timelines, :federated], false)
	+
	+ conn = get(conn, "/api/v2/instance")
	+
	+ assert result = json_response_and_validate_schema(conn, 200)
	+
	+ assert result["configuration"]["timelines_access"] == %{
	+ "live_feeds" => %{
	+ "local" => "authenticated",
	+ "remote" => "public"
	+ },
	+ "hashtag_feeds" => %{
	+ "local" => "authenticated",
	+ "remote" => "public"
	+ },
	+ "trending_link_feeds" => %{
	+ "local" => "disabled",
	+ "remote" => "disabled"
	+ }
	+ }
	+ end
	end
	diff --git a/test/pleroma/web/pleroma_api/controllers/account_controller_test.exs b/test/pleroma/web/pleroma_api/controllers/account_controller_test.exs
	index d152a44cd..38a928f30 100644
	--- a/test/pleroma/web/pleroma_api/controllers/account_controller_test.exs
	+++ b/test/pleroma/web/pleroma_api/controllers/account_controller_test.exs
	@@ -1,366 +1,337 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.AccountControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Config
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory
	import Swoosh.TestAssertions

	describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
	setup do
	{:ok, user} =
	insert(:user)
	\|> User.confirmation_changeset(set_confirmation: false)
	\|> User.update_and_set_cache()

	refute user.is_confirmed

	[user: user]
	end

	setup do: clear_config([:instance, :account_activation_required], true)

	test "resend account confirmation email", %{conn: conn, user: user} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/accounts/confirmation_resend?email=#{user.email}")
	\|> json_response_and_validate_schema(:no_content)

	ObanHelpers.perform_all()

	email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
	notify_email = Config.get([:instance, :notify_email])
	instance_name = Config.get([:instance, :name])

	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end

	test "resend account confirmation email (with nickname)", %{conn: conn, user: user} do
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/pleroma/accounts/confirmation_resend?nickname=#{user.nickname}")
	\|> json_response_and_validate_schema(:no_content)

	ObanHelpers.perform_all()

	email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
	notify_email = Config.get([:instance, :notify_email])
	instance_name = Config.get([:instance, :name])

	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end
	end

	describe "getting favorites timeline of specified user" do
	setup do
	[current_user, user] = insert_pair(:user, hide_favorites: false)
	%{user: current_user, conn: conn} = oauth_access(["read:favourites"], user: current_user)
	[current_user: current_user, user: user, conn: conn]
	end

	test "returns list of statuses favorited by specified user", %{
	conn: conn,
	user: user
	} do
	[activity \| _] = insert_pair(:note_activity)
	CommonAPI.favorite(activity.id, user)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(:ok)

	[like] = response

	assert length(response) == 1
	assert like["id"] == activity.id
	end

	test "returns favorites for specified user_id when requester is not logged in", %{
	user: user
	} do
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	response =
	build_conn()
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 1
	end

	test "returns favorited DM only when user is logged in and he is one of recipients", %{
	current_user: current_user,
	user: user
	} do
	{:ok, direct} =
	CommonAPI.post(current_user, %{
	status: "Hi @#{user.nickname}!",
	visibility: "direct"
	})

	CommonAPI.favorite(direct.id, user)

	for u <- [user, current_user] do
	response =
	build_conn()
	\|> assign(:user, u)
	\|> assign(:token, insert(:oauth_token, user: u, scopes: ["read:favourites"]))
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(:ok)

	assert length(response) == 1
	end

	response =
	build_conn()
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(200)

	assert length(response) == 0
	end

	test "does not return others' favorited DM when user is not one of recipients", %{
	conn: conn,
	user: user
	} do
	user_two = insert(:user)

	{:ok, direct} =
	CommonAPI.post(user_two, %{
	status: "Hi @#{user.nickname}!",
	visibility: "direct"
	})

	CommonAPI.favorite(direct.id, user)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "paginates favorites using since_id and max_id", %{
	conn: conn,
	user: user
	} do
	activities = insert_list(10, :note_activity)

	Enum.each(activities, fn activity ->
	CommonAPI.favorite(activity.id, user)
	end)

	third_activity = Enum.at(activities, 2)
	seventh_activity = Enum.at(activities, 6)

	response =
	conn
	\|> get(
	"/api/v1/pleroma/accounts/#{user.id}/favourites?since_id=#{third_activity.id}&max_id=#{seventh_activity.id}"
	)
	\|> json_response_and_validate_schema(:ok)

	assert length(response) == 3
	refute third_activity in response
	refute seventh_activity in response
	end

	test "limits favorites using limit parameter", %{
	conn: conn,
	user: user
	} do
	7
	\|> insert_list(:note_activity)
	\|> Enum.each(fn activity ->
	CommonAPI.favorite(activity.id, user)
	end)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites?limit=3")
	\|> json_response_and_validate_schema(:ok)

	assert length(response) == 3
	end

	test "returns empty response when user does not have any favorited statuses", %{
	conn: conn,
	user: user
	} do
	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response_and_validate_schema(:ok)

	assert Enum.empty?(response)
	end

	test "returns 404 error when specified user is not exist", %{conn: conn} do
	conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end

	test "returns 403 error when user has hidden own favorites", %{conn: conn} do
	user = insert(:user, hide_favorites: true)
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/favourites")

	assert json_response_and_validate_schema(conn, 403) == %{"error" => "Can't get favorites"}
	end

	test "hides favorites for new users by default", %{conn: conn} do
	user = insert(:user)
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	assert user.hide_favorites
	conn = get(conn, "/api/v1/pleroma/accounts/#{user.id}/favourites")

	assert json_response_and_validate_schema(conn, 403) == %{"error" => "Can't get favorites"}
	end
	end

	describe "subscribing / unsubscribing" do
	test "subscribing / unsubscribing to a user" do
	%{user: user, conn: conn} = oauth_access(["follow"])
	subscription_target = insert(:user)

	ret_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")

	assert %{"id" => _id, "subscribing" => true} =
	json_response_and_validate_schema(ret_conn, 200)

	conn = post(conn, "/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")

	assert %{"id" => _id, "subscribing" => false} = json_response_and_validate_schema(conn, 200)
	end
	end

	describe "subscribing" do
	test "returns 404 when subscription_target not found" do
	%{conn: conn} = oauth_access(["write:follows"])

	conn = post(conn, "/api/v1/pleroma/accounts/target_id/subscribe")

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
	end
	end

	describe "unsubscribing" do
	test "returns 404 when subscription_target not found" do
	%{conn: conn} = oauth_access(["follow"])

	conn = post(conn, "/api/v1/pleroma/accounts/target_id/unsubscribe")

	assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
	end
	end

	- describe "account endorsements" do
	- test "returns a list of pinned accounts", %{conn: conn} do
	- %{id: id1} = user1 = insert(:user)
	- %{id: id2} = user2 = insert(:user)
	- %{id: id3} = user3 = insert(:user)
	-
	- CommonAPI.follow(user2, user1)
	- CommonAPI.follow(user3, user1)
	-
	- User.endorse(user1, user2)
	- User.endorse(user1, user3)
	-
	- response =
	- conn
	- \|> get("/api/v1/pleroma/accounts/#{id1}/endorsements")
	- \|> json_response_and_validate_schema(200)
	-
	- assert length(response) == 2
	- assert Enum.any?(response, fn user -> user["id"] == id2 end)
	- assert Enum.any?(response, fn user -> user["id"] == id3 end)
	- end
	-
	- test "returns 404 error when specified user is not exist", %{conn: conn} do
	- conn = get(conn, "/api/v1/pleroma/accounts/test/endorsements")
	-
	- assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	- end
	- end
	-
	describe "birthday reminders" do
	test "returns a list of friends having birthday on specified day" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	%{id: id1} =
	user1 =
	insert(:user, %{
	birthday: "2001-02-12",
	show_birthday: true
	})

	user2 =
	insert(:user, %{
	birthday: "2001-02-14",
	show_birthday: true
	})

	user3 = insert(:user)

	CommonAPI.follow(user1, user)
	CommonAPI.follow(user2, user)
	CommonAPI.follow(user3, user)

	[%{"id" => ^id1}] =
	conn
	\|> get("/api/v1/pleroma/birthdays?day=12&month=2")
	\|> json_response_and_validate_schema(:ok)
	end

	test "the list doesn't list friends with hidden birth date" do
	%{user: user, conn: conn} = oauth_access(["read:accounts"])

	user1 =
	insert(:user, %{
	birthday: "2001-02-12",
	show_birthday: false
	})

	%{id: id2} =
	user2 =
	insert(:user, %{
	birthday: "2001-02-12",
	show_birthday: true
	})

	CommonAPI.follow(user1, user)
	CommonAPI.follow(user2, user)

	[%{"id" => ^id2}] =
	conn
	\|> get("/api/v1/pleroma/birthdays?day=12&month=2")
	\|> json_response_and_validate_schema(:ok)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 7:24 AM (21 h, 20 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799778
Default Alt Text: (683 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions