No OneTemporary
Actions

Authored By

Unknown

Size

684 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 76d1a4210..39947c75e 100644
	--- a/.gitlab-ci.yml
	+++ b/.gitlab-ci.yml
	@@ -1,539 +1,539 @@
	-image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.13.4-otp-25
	+image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.14.5-otp-25

	variables: &global_variables
	# Only used for the release
	- ELIXIR_VER: 1.13.4
	+ ELIXIR_VER: 1.14.5
	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 && $CI_OPEN_MERGE_REQUESTS
	when: never
	- if: $CI_COMMIT_BRANCH

	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: {}
	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

	-build-1.13.4-otp-25:
	+build-1.14.5-otp-25:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: build
	script:
	- mix compile --force

	build-1.17.1-otp-26:
	extends:
	- .build_changes_policy
	- .using-ci-base
	stage: build
	image: git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.17.1-otp-26
	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
	script:
	- mix pleroma.openapi_spec spec.json

	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.13.4-otp-25:
	+unit-testing-1.14.5-otp-25:
	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"]
	script: &testing_script
	- mix ecto.create
	- mix ecto.migrate
	- mix pleroma.test_runner --cover --preload-modules
	coverage: '/^Line total: ([^ ]*%)$/'
	artifacts:
	reports:
	coverage_report:
	coverage_format: cobertura
	path: coverage.xml

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

	formatting-1.15:
	extends: .build_changes_policy
	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
	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
	cache: *testing_cache_policy
	tags:
	- feld
	script:
	- mix dialyzer

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

	spec-deploy:
	stage: deploy
	artifacts:
	paths:
	- spec.json
	only:
	- develop@pleroma/pleroma
	image: alpine:latest
	before_script:
	- apk add curl
	script:
	- curl --fail-with-body -X POST -F"token=$CI_JOB_TOKEN" -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


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

	amd64:
	stage: release
	image: elixir:$ELIXIR_VER
	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
	before_script: &before-release
	- apt-get update && apt-get install -y cmake libmagic-dev libvips-dev erlang-dev
	- 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: elixir:$ELIXIR_VER-alpine
	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
	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: arm64v8/elixir:$ELIXIR_VER
	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: arm64v8/elixir:$ELIXIR_VER-alpine
	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/Dockerfile b/Dockerfile
	index 72461305c..fff58154e 100644
	--- a/Dockerfile
	+++ b/Dockerfile
	@@ -1,58 +1,59 @@
	+# https://hub.docker.com/r/hexpm/elixir/tags
	ARG ELIXIR_IMG=hexpm/elixir
	-ARG ELIXIR_VER=1.13.4
	-ARG ERLANG_VER=24.3.4.15
	-ARG ALPINE_VER=3.17.5
	+ARG ELIXIR_VER=1.14.5
	+ARG ERLANG_VER=25.3.2.14
	+ARG ALPINE_VER=3.17.9

	FROM ${ELIXIR_IMG}:${ELIXIR_VER}-erlang-${ERLANG_VER}-alpine-${ALPINE_VER} as build

	COPY . .

	ENV MIX_ENV=prod
	ENV VIX_COMPILATION_MODE=PLATFORM_PROVIDED_LIBVIPS

	RUN apk add git gcc g++ musl-dev make cmake file-dev vips-dev &&\
	echo "import Config" > config/prod.secret.exs &&\
	mix local.hex --force &&\
	mix local.rebar --force &&\
	mix deps.get --only prod &&\
	mkdir release &&\
	mix release --path release

	FROM alpine:${ALPINE_VER}

	ARG BUILD_DATE
	ARG VCS_REF

	LABEL maintainer="ops@pleroma.social" \
	org.opencontainers.image.title="pleroma" \
	org.opencontainers.image.description="Pleroma for Docker" \
	org.opencontainers.image.authors="ops@pleroma.social" \
	org.opencontainers.image.vendor="pleroma.social" \
	org.opencontainers.image.documentation="https://git.pleroma.social/pleroma/pleroma" \
	org.opencontainers.image.licenses="AGPL-3.0" \
	org.opencontainers.image.url="https://pleroma.social" \
	org.opencontainers.image.revision=$VCS_REF \
	org.opencontainers.image.created=$BUILD_DATE

	ARG HOME=/opt/pleroma
	ARG DATA=/var/lib/pleroma

	RUN apk update &&\
	apk add exiftool ffmpeg vips libmagic ncurses postgresql-client &&\
	adduser --system --shell /bin/false --home ${HOME} pleroma &&\
	mkdir -p ${DATA}/uploads &&\
	mkdir -p ${DATA}/static &&\
	chown -R pleroma ${DATA} &&\
	mkdir -p /etc/pleroma &&\
	chown -R pleroma /etc/pleroma

	USER pleroma

	COPY --from=build --chown=pleroma:0 /release ${HOME}

	COPY --chown=pleroma --chmod=640 ./config/docker.exs /etc/pleroma/config.exs
	COPY ./docker-entrypoint.sh ${HOME}

	EXPOSE 4000

	ENTRYPOINT ["/opt/pleroma/docker-entrypoint.sh"]
	diff --git a/changelog.d/debian-install-improve.skip b/changelog.d/debian-install-improve.skip
	new file mode 100644
	index 000000000..6068a3066
	--- /dev/null
	+++ b/changelog.d/debian-install-improve.skip
	@@ -0,0 +1 @@
	+Fixed a formatting issue that had a required commend embedded in a textblock, and change the language to make it a bit more idiomatic.
	\ No newline at end of file
	diff --git a/changelog.d/docs-vips.skip b/changelog.d/docs-vips.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/elixir-1.14-docker.skip b/changelog.d/elixir-1.14-docker.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/elixir.change b/changelog.d/elixir.change
	new file mode 100644
	index 000000000..779c01562
	--- /dev/null
	+++ b/changelog.d/elixir.change
	@@ -0,0 +1 @@
	+Elixir 1.14 and Erlang/OTP 23 is now the minimum supported release
	diff --git a/changelog.d/freebsd-docs.skip b/changelog.d/freebsd-docs.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/hashtag-feeds-restricted.add b/changelog.d/hashtag-feeds-restricted.add
	new file mode 100644
	index 000000000..accac9c9c
	--- /dev/null
	+++ b/changelog.d/hashtag-feeds-restricted.add
	@@ -0,0 +1 @@
	+Repesct :restrict_unauthenticated for hashtag rss/atom feeds
	\ No newline at end of file
	diff --git a/changelog.d/incoming-blocks.fix b/changelog.d/incoming-blocks.fix
	new file mode 100644
	index 000000000..3228d7318
	--- /dev/null
	+++ b/changelog.d/incoming-blocks.fix
	@@ -0,0 +1 @@
	+Fix incoming Block activities being rejected
	diff --git a/changelog.d/ldap-password-change.add b/changelog.d/ldap-password-change.add
	new file mode 100644
	index 000000000..7ca555ee4
	--- /dev/null
	+++ b/changelog.d/ldap-password-change.add
	@@ -0,0 +1 @@
	+LDAP now supports users changing their passwords
	diff --git a/changelog.d/mediav2_status.fix b/changelog.d/mediav2_status.fix
	new file mode 100644
	index 000000000..28e93e030
	--- /dev/null
	+++ b/changelog.d/mediav2_status.fix
	@@ -0,0 +1 @@
	+Fix /api/v2/media returning the wrong status code (202) for media processed synchronously
	diff --git a/changelog.d/mrf-id_filter.add b/changelog.d/mrf-id_filter.add
	new file mode 100644
	index 000000000..f556f9bc4
	--- /dev/null
	+++ b/changelog.d/mrf-id_filter.add
	@@ -0,0 +1 @@
	+Add `id_filter` to MRF to filter URLs and their domain prior to fetching
	\ No newline at end of file
	diff --git a/changelog.d/oban-update.change b/changelog.d/oban-update.change
	new file mode 100644
	index 000000000..48a54ed2d
	--- /dev/null
	+++ b/changelog.d/oban-update.change
	@@ -0,0 +1 @@
	+Oban updated to 2.18.3
	diff --git a/changelog.d/poll-refresh.change b/changelog.d/poll-refresh.change
	new file mode 100644
	index 000000000..b755128a1
	--- /dev/null
	+++ b/changelog.d/poll-refresh.change
	@@ -0,0 +1 @@
	+Poll results refreshing is handled asynchronously and will not attempt to keep fetching updates to a closed poll.
	diff --git a/changelog.d/profile-image-descriptions.skip b/changelog.d/profile-image-descriptions.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/changelog.d/release-tuning.change b/changelog.d/release-tuning.change
	new file mode 100644
	index 000000000..bf9abc3ad
	--- /dev/null
	+++ b/changelog.d/release-tuning.change
	@@ -0,0 +1 @@
	+Tuning for release builds to lower CPU usage.
	diff --git a/changelog.d/remote-report-policy.add b/changelog.d/remote-report-policy.add
	new file mode 100644
	index 000000000..1cf25b1a8
	--- /dev/null
	+++ b/changelog.d/remote-report-policy.add
	@@ -0,0 +1 @@
	+Added RemoteReportPolicy from Rebased for handling bogus federated reports
	diff --git a/ci/elixir-1.12/Dockerfile b/ci/elixir-1.12/Dockerfile
	deleted file mode 100644
	index a2b566873..000000000
	--- a/ci/elixir-1.12/Dockerfile
	+++ /dev/null
	@@ -1,8 +0,0 @@
	-FROM elixir:1.12.3
	-
	-# Single RUN statement, otherwise intermediate images are created
	-# https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#run
	-RUN apt-get update &&\
	- apt-get install -y libmagic-dev cmake libimage-exiftool-perl ffmpeg &&\
	- mix local.hex --force &&\
	- mix local.rebar --force
	diff --git a/ci/elixir-1.12/build_and_push.sh b/ci/elixir-1.12/build_and_push.sh
	deleted file mode 100755
	index 508262ed8..000000000
	--- a/ci/elixir-1.12/build_and_push.sh
	+++ /dev/null
	@@ -1 +0,0 @@
	-docker buildx build --platform linux/amd64,linux/arm64,linux/arm/v7 -t git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.12 --push .
	diff --git a/ci/elixir-1.13.4-otp-25/Dockerfile b/ci/elixir-1.14.5-otp-25/Dockerfile
	similarity index 91%
	rename from ci/elixir-1.13.4-otp-25/Dockerfile
	rename to ci/elixir-1.14.5-otp-25/Dockerfile
	index 25a1639e8..3a35c84c3 100644
	--- a/ci/elixir-1.13.4-otp-25/Dockerfile
	+++ b/ci/elixir-1.14.5-otp-25/Dockerfile
	@@ -1,8 +1,8 @@
	-FROM elixir:1.13.4-otp-25
	+FROM elixir:1.14.5-otp-25

	# Single RUN statement, otherwise intermediate images are created
	# https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#run
	RUN apt-get update &&\
	apt-get install -y libmagic-dev cmake libimage-exiftool-perl ffmpeg &&\
	mix local.hex --force &&\
	mix local.rebar --force
	diff --git a/ci/elixir-1.13.4-otp-25/build_and_push.sh b/ci/elixir-1.14.5-otp-25/build_and_push.sh
	similarity index 52%
	rename from ci/elixir-1.13.4-otp-25/build_and_push.sh
	rename to ci/elixir-1.14.5-otp-25/build_and_push.sh
	index b8ca1d24d..912c47d0c 100755
	--- a/ci/elixir-1.13.4-otp-25/build_and_push.sh
	+++ b/ci/elixir-1.14.5-otp-25/build_and_push.sh
	@@ -1 +1 @@
	-docker buildx build --platform linux/amd64,linux/arm64 -t git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.13.4-otp-25 --push .
	+docker buildx build --platform linux/amd64,linux/arm64 -t git.pleroma.social:5050/pleroma/pleroma/ci-base:elixir-1.14.5-otp-25 --push .
	diff --git a/config/config.exs b/config/config.exs
	index 47ddfac5a..07e98011d 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,950 +1,955 @@
	# .i;;;;i.
	# iYcviii;vXY:
	# .YXi .i1c.
	# .YC. . in7.
	# .vc. ...... ;1c.
	# i7, .. .;1;
	# i7, .. ... .Y1i
	# ,7v .6MMM@; .YX,
	# .7;. ..IMMMMMM1 :t7.
	# .;Y. ;$MMMMMM9. :tc.
	# vY. .. .nMMM@MMU. ;1v.
	# i7i ... .#MM@M@C. .....:71i
	# it: .... $MMM@9;.,i;;;i,;tti
	# :t7. ..... 0MMMWv.,iii:::,,;St.
	# .nC. ..... IMMMQ..,::::::,.,czX.
	# .ct: ....... .ZMMMI..,:::::::,,:76Y.
	# c2: ......,i..Y$M@t..:::::::,,..inZY
	# vov ......:ii..c$MBc..,,,,,,,,,,..iI9i
	# i9Y ......iii:..7@MA,..,,,,,,,,,....;AA:
	# iIS. ......:ii::..;@MI....,............;Ez.
	# .I9. ......:i::::...8M1..................C0z.
	# .z9; ......:i::::,.. .i:...................zWX.
	# vbv ......,i::::,,. ................. :AQY
	# c6Y. .,...,::::,,..:t0@@QY. ................ :8bi
	# :6S. ..,,...,:::,,,..EMMMMMMI. ............... .;bZ,
	# :6o, .,,,,..:::,,,..i#MMMMMM#v................. YW2.
	# .n8i ..,,,,,,,::,,,,.. tMMMMM@C:.................. .1Wn
	# 7Uc. .:::,,,,,::,,,,.. i1t;,..................... .UEi
	# 7C...::::::::::::,,,,.. .................... vSi.
	# ;1;...,,::::::,......... .................. Yz:
	# v97,......... .voC.
	# izAotX7777777777777777777777777777777777777777Y7n92:
	# .;CoIIIIIUAA666666699999ZZZZZZZZZZZZZZZZZZZZ6ov.
	#
	# !!! ATTENTION !!!
	# DO NOT EDIT THIS FILE! THIS FILE CONTAINS THE DEFAULT VALUES FOR THE CON-
	# FIGURATION! EDIT YOUR SECRET FILE (either prod.secret.exs, dev.secret.exs).
	#
	# This file is responsible for configuring your application
	# and its dependencies with the aid of the Config module.
	#
	# This configuration file is loaded before any dependency and
	# is restricted to this project.
	import Config

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

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

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

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

	# Upload configuration
	config :pleroma, Pleroma.Upload,
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: false,
	proxy_remote: false,
	filename_display_max_length: 30,
	default_description: nil,
	base_url: nil

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

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

	config :ex_aws, :s3,
	# host: "s3.wasabisys.com", # required if not Amazon AWS
	access_key_id: nil,
	secret_access_key: nil,
	# region: "us-east-1", # may be required for Amazon AWS
	scheme: "https://"

	config :pleroma, Pleroma.Uploaders.IPFS,
	post_gateway_url: "http://localhost:5001",
	get_gateway_url: "http://localhost:8080"

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

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

	# Configures the endpoint
	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "localhost"],
	http: [
	ip: {127, 0, 0, 1}
	],
	protocol: "https",
	secret_key_base: "aK4Abxf29xU9TTDKre9coZPUgevcVCFQJe/5xP/7Lt4BEif6idBIbjupVbOrbKxl",
	live_view: [signing_salt: "U5ELgdEwTD3n1+D5s0rY0AMg8/y1STxZ3Zvsl3bWh+oBcGrYdil0rXqPMRd3Glcq"],
	signing_salt: "CqaoopA2",
	render_errors: [view: Pleroma.Web.ErrorView, accepts: ~w(json)],
	pubsub_server: Pleroma.PubSub,
	secure_cookie_flag: true,
	extra_cookie_attrs: [
	"SameSite=Lax"
	]

	# Configures Elixir's Logger
	config :logger, backends: [:console]

	config :logger, :console,
	level: :debug,
	format: "\n$time $metadata[$level] $message\n",
	metadata: [:actor, :path, :type, :user]

	config :logger, :ex_syslogger,
	level: :debug,
	ident: "pleroma",
	format: "$metadata[$level] $message",
	metadata: [:actor, :path, :type, :user]

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

	config :tesla, adapter: Tesla.Adapter.Hackney

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

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

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

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

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

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

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

	config :pleroma, :manifest,
	icons: [
	%{
	src: "/static/logo.svg",
	sizes: "512x512",
	purpose: "any",
	type: "image/svg+xml"
	}
	],
	theme_color: "#282c37",
	background_color: "#191b22"

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

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

	config :pleroma, :user, deny_follow_blocked: true

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

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

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

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

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

	config :pleroma, :mrf_emoji,
	remove_url: [],
	remove_shortcode: [],
	federated_timeline_removal_url: [],
	federated_timeline_removal_shortcode: []

	config :pleroma, :mrf_hashtag,
	sensitive: ["nsfw"],
	reject: [],
	federated_timeline_removal: []

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

	config :pleroma, :mrf_activity_expiration, days: 365

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

	config :pleroma, :mrf_dnsrbl,
	nameserver: "127.0.0.1",
	port: 53,
	zone: "bl.pleroma.com"

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

	config :pleroma, :mrf_nsfw_api,
	url: "http://127.0.0.1:5000/",
	threshold: 0.7,
	mark_sensitive: true,
	unlist: false,
	reject: false

	config :pleroma, :mrf_follow_bot, follower_nickname: nil

	config :pleroma, :mrf_inline_quote, template: "<bdi>RT:</bdi> {url}"

	+config :pleroma, :mrf_remote_report,
	+ reject_all: false,
	+ reject_anonymous: true,
	+ reject_empty_message: true
	+
	config :pleroma, :mrf_force_mention,
	mention_parent: true,
	mention_quoted: true

	config :pleroma, :mrf_antimentionspam, user_age_limit: 30_000

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

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

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

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

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

	config :pleroma, :shout,
	enabled: true,
	limit: 5_000

	config :phoenix, :format_encoders, json: Jason, "activity+json": Jason

	config :phoenix, :json_library, Jason

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

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

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

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

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

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

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

	# The Pruner :max_age must be longer than Worker :unique
	# value or it cannot enforce uniqueness.
	config :pleroma, Oban,
	repo: Pleroma.Repo,
	log: false,
	queues: [
	activity_expiration: 10,
	federator_incoming: 5,
	federator_outgoing: 25,
	web_push: 50,
	background: 20,
	search_indexing: [limit: 10, paused: true],
	slow: 5
	],
	plugins: [{Oban.Plugins.Pruner, max_age: 900}],
	crontab: [
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker},
	{"/10 * * *", Pleroma.Workers.Cron.AppCleanupWorker}
	]

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

	config :pleroma, :ldap,
	enabled: System.get_env("LDAP_ENABLED") == "true",
	host: System.get_env("LDAP_HOST", "localhost"),
	port: String.to_integer(System.get_env("LDAP_PORT", "389")),
	ssl: System.get_env("LDAP_SSL") == "true",
	sslopts: [],
	tls: System.get_env("LDAP_TLS") == "true",
	tlsopts: [],
	base: System.get_env("LDAP_BASE", "dc=example,dc=com"),
	uid: System.get_env("LDAP_UID", "cn"),
	# defaults to CAStore's Mozilla roots
	cacertfile: System.get_env("LDAP_CACERTFILE", nil),
	mail: System.get_env("LDAP_MAIL", "mail")

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

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

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

	config :pleroma, :auth, oauth_consumer_strategies: oauth_consumer_strategies

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

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

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

	config :pleroma, Pleroma.PromEx,
	disabled: false,
	manual_metrics_start_delay: :no_delay,
	drop_metrics_groups: [],
	grafana: [
	host: System.get_env("GRAFANA_HOST", "http://localhost:3000"),
	auth_token: System.get_env("GRAFANA_TOKEN"),
	upload_dashboards_on_start: false,
	folder_name: "BEAM",
	annotate_app_lifecycle: true
	],
	metrics_server: [
	port: 4021,
	path: "/metrics",
	protocol: :http,
	pool_size: 5,
	cowboy_opts: [],
	auth_strategy: :none
	],
	datasource: "Prometheus"

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

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

	config :pleroma, :oauth2,
	token_expires_in: 3600 * 24 * 365 * 100,
	issue_new_refresh_token: true,
	clean_expired_tokens: false

	config :pleroma, :database, rum_enabled: false

	config :pleroma, :features, improved_hashtag_timeline: :auto

	config :pleroma, :populate_hashtags_table, fault_rate_allowance: 0.01

	config :pleroma, :delete_context_objects, fault_rate_allowance: 0.01

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

	config :http_signatures,
	adapter: Pleroma.Signature

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

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

	config :pleroma, Pleroma.Web.Plugs.RemoteIp,
	enabled: true,
	headers: ["x-forwarded-for"],
	proxies: [],
	reserved: [
	"127.0.0.0/8",
	"::1/128",
	"fc00::/7",
	"10.0.0.0/8",
	"172.16.0.0/12",
	"192.168.0.0/16"
	]

	config :pleroma, :static_fe, enabled: false

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

	config :pleroma, :frontends,
	available: %{
	"kenoma" => %{
	"name" => "kenoma",
	"git" => "https://git.pleroma.social/lambadalambda/kenoma",
	"build_url" =>
	"https://git.pleroma.social/lambadalambda/kenoma/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "master"
	},
	"pleroma-fe" => %{
	"name" => "pleroma-fe",
	"git" => "https://git.pleroma.social/pleroma/pleroma-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/pleroma-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"fedi-fe" => %{
	"name" => "fedi-fe",
	"git" => "https://git.pleroma.social/pleroma/fedi-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/fedi-fe/-/jobs/artifacts/${ref}/download?job=build_release",
	"ref" => "master",
	"custom-http-headers" => [
	{"service-worker-allowed", "/"}
	]
	},
	"admin-fe" => %{
	"name" => "admin-fe",
	"git" => "https://git.pleroma.social/pleroma/admin-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/admin-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"soapbox" => %{
	"name" => "soapbox",
	"git" => "https://gitlab.com/soapbox-pub/soapbox",
	"build_url" =>
	"https://gitlab.com/soapbox-pub/soapbox/-/jobs/artifacts/${ref}/download?job=build-production",
	"ref" => "v3.0.0-beta.1",
	"build_dir" => "static"
	},
	"glitch-lily" => %{
	"name" => "glitch-lily",
	"git" => "https://lily-is.land/infra/glitch-lily",
	"build_url" =>
	"https://lily-is.land/infra/glitch-lily/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "servant",
	"build_dir" => "public"
	}
	}

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

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

	config :pleroma, configurable_from_database: false

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

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

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

	config :pleroma, :hackney_pools,
	federation: [
	max_connections: 50,
	timeout: 10_000
	],
	media: [
	max_connections: 50,
	timeout: 15_000
	],
	rich_media: [
	max_connections: 50,
	timeout: 15_000
	],
	upload: [
	max_connections: 25,
	timeout: 15_000
	]

	config :pleroma, :majic_pool, size: 2

	private_instance? = :if_instance_is_private

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

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

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

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

	config :ex_aws, http_client: Pleroma.HTTP.ExAws

	config :web_push_encryption, http_client: Pleroma.HTTP.WebPush

	config :pleroma, :instances_favicons, enabled: false

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

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

	config :pleroma, Pleroma.User.Backup,
	purge_after_days: 30,
	limit_days: 7,
	dir: nil,
	process_chunk_size: 100,
	timeout: :timer.minutes(30)

	config :pleroma, ConcurrentLimiter, [
	{Pleroma.Search, [max_running: 30, max_waiting: 50]}
	]

	config :pleroma, Pleroma.Web.WebFinger, domain: nil, update_nickname_on_user_fetch: true

	config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch

	config :pleroma, Pleroma.Search.Meilisearch,
	url: "http://127.0.0.1:7700/",
	private_key: nil,
	initial_indexing_chunk_size: 100_000

	config :pleroma, Pleroma.Application,
	background_migrators: true,
	internal_fetch: true,
	load_custom_modules: true,
	max_restarts: 3,
	streamer_registry: true

	config :pleroma, Pleroma.Uploaders.Uploader, timeout: 30_000

	config :pleroma, Pleroma.Search.QdrantSearch,
	qdrant_url: "http://127.0.0.1:6333/",
	qdrant_api_key: "",
	openai_url: "http://127.0.0.1:11345",
	# The healthcheck url has to be set to nil when used with the real openai
	# API, as it doesn't have a healthcheck endpoint.
	openai_healthcheck_url: "http://127.0.0.1:11345/health",
	openai_model: "snowflake/snowflake-arctic-embed-xs",
	openai_api_key: "",
	qdrant_index_configuration: %{
	vectors: %{size: 384, distance: "Cosine"}
	}

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env()}.exs"
	diff --git a/docs/installation/debian_based_en.md b/docs/installation/debian_based_en.md
	index b61e4addd..21cfe2bff 100644
	--- a/docs/installation/debian_based_en.md
	+++ b/docs/installation/debian_based_en.md
	@@ -1,189 +1,195 @@
	# Installing on Debian Based Distributions

	{! backend/installation/otp_vs_from_source_source.include !}

	## Installation

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

	{! backend/installation/generic_dependencies.include !}

	### Prepare the system

	* First update the system, if not already done:

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

	* Install some of the above mentioned programs:

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

	### Install Elixir and Erlang

	* Install Elixir and Erlang (you might need to use backports or [asdf](https://github.com/asdf-vm/asdf) on old systems):

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


	### Optional packages: [`docs/installation/optional/media_graphics_packages.md`](../installation/optional/media_graphics_packages.md)

	```shell
	sudo apt install imagemagick ffmpeg libimage-exiftool-perl
	```

	### Install PleromaBE

	* Add a new system user for the Pleroma service:

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

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

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

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

	* Change to the new directory:

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

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

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

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

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

	```shell
	sudo -Hu pleroma mv config/{generated_config.exs,prod.secret.exs}
	```


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

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

	* Now run the database migration:

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

	* Now you can start Pleroma already

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

	### Finalize installation

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

	#### Nginx

	* Install nginx, if not already done:

	```shell
	sudo apt install nginx
	```

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

	```shell
	sudo apt install certbot
	```

	and then set it up:

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

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

	---

	* Copy the example nginx configuration and activate it:

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

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

	* (Strongly recommended) serve media on another domain

	Refer to the [Hardening your instance](../configuration/hardening.md) document on how to serve media on another domain. We STRONGLY RECOMMEND you to do this to minimize attack vectors.

	* Enable and start nginx:

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

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

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

	#### Other webserver/proxies

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

	#### Systemd service

	* Copy example service file

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

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

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

	#### Create your first user

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

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

	#### Further reading

	{! backend/installation/further_reading.include !}

	## Questions

	Questions about the installation or didn’t it work as it should be, ask in [#pleroma:libera.chat](https://matrix.to/#/#pleroma:libera.chat) via Matrix or #pleroma on libera.chat via IRC.
	diff --git a/docs/installation/debian_based_jp.md b/docs/installation/debian_based_jp.md
	index 5a0823a63..0817934ff 100644
	--- a/docs/installation/debian_based_jp.md
	+++ b/docs/installation/debian_based_jp.md
	@@ -1,198 +1,198 @@
	# Pleromaの入れ方

	Note: This article is potentially outdated because at this time we may not have people who can speak this language well enough to update it. To see the up-to-date version, which may have significant differences or important caveats of the installation process, look up the English version.

	## 日本語訳について

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

	## インストール

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

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

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

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

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

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

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

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

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

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

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

	### オプションパッケージ: [`docs/installation/optional/media_graphics_packages.md`](../installation/optional/media_graphics_packages.md)

	```shell
	sudo apt install imagemagick ffmpeg libimage-exiftool-perl
	```

	### Pleroma BE (バックエンド) をインストールします

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

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

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

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

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

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

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


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

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

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

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

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

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

	#### Nginx

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

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

	---

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

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

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

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

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

	#### Systemd サービス

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

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

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

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

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

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

	{! backend/installation/further_reading.include !}

	## 質問ある？

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

	* [#pleroma:libera.chat](https://matrix.to/#/#pleroma:libera.chat)
	* libera.chat の #pleroma IRCチャンネル
	diff --git a/docs/installation/freebsd_en.md b/docs/installation/freebsd_en.md
	index 02513daf2..920bc7d35 100644
	--- a/docs/installation/freebsd_en.md
	+++ b/docs/installation/freebsd_en.md
	@@ -1,223 +1,223 @@
	# Installing on FreeBSD

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

	{! backend/installation/generic_dependencies.include !}

	## Installing software used in this guide

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

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

	Copy the rc.d scripts to the right directory:

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

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

	## Initialize postgres

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

	### Install media / graphics packages (optional, see [`docs/installation/optional/media_graphics_packages.md`](../installation/optional/media_graphics_packages.md))

	```shell
	-# pkg install imagemagick ffmpeg p5-Image-ExifTool
	+# pkg install imagemagick ffmpeg p5-Image-ExifTool vips
	```

	## Configuring Pleroma

	Create a user for Pleroma:

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

	Clone the repository:

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

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

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

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

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

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

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

	Run the database migrations.

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

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

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

	## Configuring acme.sh

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

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

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

	Next, obtain your account fingerprint:

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

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

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

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

	Start nginx:

	```
	# service nginx start
	```

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

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

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

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

	### Configuring nginx

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


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

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


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

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

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

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

	#### (Strongly recommended) serve media on another domain

	Refer to the [Hardening your instance](../configuration/hardening.md) document on how to serve media on another domain. We STRONGLY RECOMMEND you to do this to minimize attack vectors.

	## Creating a startup script for Pleroma

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

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

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

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

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

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

	#### Create your first user

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

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

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

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

	## Questions

	Questions about the installation or didn’t it work as it should be, ask in [#pleroma:libera.chat](https://matrix.to/#/#pleroma:libera.chat) via Matrix or #pleroma on libera.chat via IRC.
	diff --git a/docs/installation/generic_dependencies.include b/docs/installation/generic_dependencies.include
	index bdb7f94d3..9f07f62c6 100644
	--- a/docs/installation/generic_dependencies.include
	+++ b/docs/installation/generic_dependencies.include
	@@ -1,16 +1,16 @@
	## Required dependencies

	* PostgreSQL >=11.0
	-* Elixir >=1.13.0 <1.17
	-* Erlang OTP >=22.2.0 (supported: <27)
	+* Elixir >=1.14.0 <1.17
	+* Erlang OTP >=23.0.0 (supported: <27)
	* git
	* file / libmagic
	* gcc or clang
	* GNU make
	* CMake

	## Optional dependencies

	* ImageMagick
	* FFmpeg
	* exiftool
	diff --git a/docs/installation/openbsd_en.md b/docs/installation/openbsd_en.md
	index e58e144d2..78bbf399f 100644
	--- a/docs/installation/openbsd_en.md
	+++ b/docs/installation/openbsd_en.md
	@@ -1,263 +1,263 @@
	# Installing on OpenBSD

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

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

	{! backend/installation/generic_dependencies.include !}

	### Preparing the system
	#### Required software

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

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

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

	#### Optional software

	Per [`docs/installation/optional/media_graphics_packages.md`](../installation/optional/media_graphics_packages.md):
	* ImageMagick
	* ffmpeg
	* exiftool

	To install the above:

	```
	pkg_add ImageMagick ffmpeg p5-Image-ExifTool
	```

	#### Creating the pleroma user
	Pleroma will be run by a dedicated user, \_pleroma. Before creating it, insert the following lines in login.conf:
	```
	pleroma:\
	:datasize-max=1536M:\
	:datasize-cur=1536M:\
	:openfiles-max=4096
	```
	This creates a "pleroma" login class and sets higher values than default for datasize and openfiles (see [login.conf(5)](https://man.openbsd.org/login.conf)), this is required to avoid having pleroma crash some time after starting.

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

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

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

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

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

	#### httpd
	httpd will have three functions:

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

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

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

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

	log syslog
	directory no index

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	match response header append "X-XSS-Protection" value "1; mode=block"
	match response header append "X-Permitted-Cross-Domain-Policies" value "none"
	match response header append "X-Frame-Options" value "DENY"
	match response header append "X-Content-Type-Options" value "nosniff"
	match response header append "Referrer-Policy" value "same-origin"
	match response header append "X-Download-Options" value "noopen"
	match response header append "Content-Security-Policy" value "default-src 'none'; base-uri 'self'; form-action 'self'; img-src 'self' data: https:; media-src 'self' https:; style-src 'self' 'unsafe-inline'; font-src 'self'; script-src 'self'; connect-src 'self' wss://CHANGEME.tld; upgrade-insecure-requests;" # Modify "CHANGEME.tld" and set your instance's domain here
	match request header append "Connection" value "upgrade"
	#match response header append "Strict-Transport-Security" value "max-age=31536000; includeSubDomains" # Uncomment this only after you get HTTPS working.

	# If you do not want remote frontends to be able to access your Pleroma backend server, comment these lines
	match response header append "Access-Control-Allow-Origin" value "*"
	match response header append "Access-Control-Allow-Methods" value "POST, PUT, DELETE, GET, PATCH, OPTIONS"
	match response header append "Access-Control-Allow-Headers" value "Authorization, Content-Type, Idempotency-Key"
	match response header append "Access-Control-Expose-Headers" value "Link, X-RateLimit-Reset, X-RateLimit-Limit, X-RateLimit-Remaining, X-Request-Id"
	# Stop commenting lines here
	}

	relay wwwtls {
	listen on $ext_inet port https tls # Comment to disable listening on IPv4
	listen on $ext_inet6 port https tls # Comment to disable listening on IPv6

	protocol plerup

	forward to <pleroma_server> port 4000 check http "/" code 200
	forward to <httpd_server> port 80 check http "/robots.txt" code 200
	}
	```
	Again, change <IPv4/6 address\> to your server's address(es) and comment one of the two listen options if needed. Also change wss://CHANGEME.tld to wss://<your instance's domain name\>.
	Check the configuration with `relayd -n`, if it is OK enable and start relayd (as root):
	```
	rcctl enable relayd
	rcctl start relayd
	```

	##### (Strongly recommended) serve media on another domain

	Refer to the [Hardening your instance](../configuration/hardening.md) document on how to serve media on another domain. We STRONGLY RECOMMEND you to do this to minimize attack vectors.

	#### pf
	Enabling and configuring pf is highly recommended.
	In /etc/pf.conf, insert the following configuration:
	```
	# Macros
	if="<network interface>"
	authorized_ssh_clients="any"

	# Skip traffic on loopback interface
	set skip on lo

	# Default behavior
	set block-policy drop
	block in log all
	pass out quick

	# Security features
	match in all scrub (no-df random-id)
	block in log from urpf-failed

	# Rules
	pass in quick on $if inet proto icmp to ($if) icmp-type { echoreq unreach paramprob trace } # ICMP
	pass in quick on $if inet6 proto icmp6 to ($if) icmp6-type { echoreq unreach paramprob timex toobig } # ICMPv6
	pass in quick on $if proto tcp to ($if) port { http https } # relayd/httpd
	pass in quick on $if proto tcp from $authorized_ssh_clients to ($if) port ssh
	```
	Replace <network interface\> by your server's network interface name (which you can get with ifconfig). Consider replacing the content of the authorized\_ssh\_clients macro by, for example, your home IP address, to avoid SSH connection attempts from bots.

	Check pf's configuration by running `pfctl -nf /etc/pf.conf`, load it with `pfctl -f /etc/pf.conf` and enable pf at boot with `rcctl enable pf`.

	#### Configure and start pleroma
	Enter a shell as \_pleroma (as root `su _pleroma -`) and enter pleroma's installation directory (`cd ~/pleroma/`).

	Then follow the main installation guide:

	* run `mix deps.get`
	* run `MIX_ENV=prod mix pleroma.instance gen` and enter your instance's information when asked
	* copy config/generated\_config.exs to config/prod.secret.exs. The default values should be sufficient but you should edit it and check that everything seems OK.
	* exit your current shell back to a root one and run `psql -U postgres -f /home/_pleroma/pleroma/config/setup_db.psql` to setup the database.
	* return to a \_pleroma shell into pleroma's installation directory (`su _pleroma -;cd ~/pleroma`) and run `MIX_ENV=prod mix ecto.migrate`

	As \_pleroma in /home/\_pleroma/pleroma, you can now run `LC_ALL=en_US.UTF-8 MIX_ENV=prod mix phx.server` to start your instance.
	In another SSH session/tmux window, check that it is working properly by running `ftp -MVo - http://127.0.0.1:4000/api/v1/instance`, you should get json output. Double-check that uri's value is your instance's domain name.

	##### Starting pleroma at boot
	An rc script to automatically start pleroma at boot hasn't been written yet, it can be run in a tmux session (tmux is in base).


	#### Create administrative user

	If your instance is up and running, you can create your first user with administrative rights with the following command as the \_pleroma user.
	```
	LC_ALL=en_US.UTF-8 MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	```

	#### Further reading

	{! backend/installation/further_reading.include !}

	## Questions

	Questions about the installation or didn’t it work as it should be, ask in [#pleroma:libera.chat](https://matrix.to/#/#pleroma:libera.chat) via Matrix or #pleroma on libera.chat via IRC.
	diff --git a/docs/installation/openbsd_fi.md b/docs/installation/openbsd_fi.md
	index 73aca3a6f..d7c94d8a0 100644
	--- a/docs/installation/openbsd_fi.md
	+++ b/docs/installation/openbsd_fi.md
	@@ -1,123 +1,123 @@
	# Pleroman asennus OpenBSD:llä

	Note: This article is potentially outdated because at this time we may not have people who can speak this language well enough to update it. To see the up-to-date version, which may have significant differences or important caveats of the installation process, look up the English version.

	Tarvitset:
	* Oman domainin
	* OpenBSD 6.3 -serverin
	* Auttavan ymmärryksen unix-järjestelmistä

	Komennot, joiden edessä on '#', tulee ajaa käyttäjänä `root`. Tämä on
	suositeltavaa tehdä komennon `doas` avulla, katso `doas (1)` ja `doas.conf (5)`.
	Tästä eteenpäin oletuksena on, että domain "esimerkki.com" osoittaa
	serverin IP-osoitteeseen.

	Jos asennuksen kanssa on ongelmia, IRC-kanava #pleroma Libera.chat tai
	Matrix-kanava #pleroma:libera.chat ovat hyviä paikkoja löytää apua
	(englanniksi), `/msg eal kukkuu` jos haluat välttämättä puhua härmää.

	Asenna tarvittava ohjelmisto:

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

	#### Optional software

	[`docs/installation/optional/media_graphics_packages.md`](../installation/optional/media_graphics_packages.md):
	* ImageMagick
	* ffmpeg
	* exiftool

	Asenna tarvittava ohjelmisto:

	`# pkg_add ImageMagick ffmpeg p5-Image-ExifTool`

	Luo postgresql-tietokanta:

	`# su - _postgresql`

	`$ mkdir /var/postgresql/data`

	`$ initdb -D /var/postgresql/data -E UTF8`

	`$ createdb`

	Käynnistä tietokanta ja aseta se käynnistymään automaattisesti.

	`# rcctl start postgresql`

	`# rcctl enable postgresql`

	Luo käyttäjä pleromaa varten (kysyy muutaman kysymyksen):

	`# adduser pleroma`

	Vaihda pleroma-käyttäjään ja mene kotihakemistoosi:

	`# su - pleroma`

	Lataa pleroman lähdekoodi:

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

	`$ cd pleroma`

	Asenna tarvittavat elixir-kirjastot:

	`$ mix deps.get`

	`$ mix deps.compile`

	Luo tarvittava konfiguraatio:

	`$ mix generate_config`

	`$ cp config/generated_config.exs config/prod.secret.exs`

	Aja luodut tietokantakomennot:

	`# su _postgres -c 'psql -f config/setup_db.psql'`

	`$ MIX_ENV=prod mix ecto.migrate`

	Käynnistä pleroma-prosessi:

	`$ MIX_ENV=prod mix compile`

	`$ MIX_ENV=prod mix phx.server`

	Tässä vaiheessa on hyvä tarkistaa että asetukset ovat oikein. Avaa selaimella,
	curlilla tai vastaavalla työkalulla `esimerkki.com:4000/api/v1/instance` ja katso
	että kohta "uri" on "https://esimerkki.com".

	Huom! Muista varmistaa että muuttuja MIX_ENV on "prod" mix-komentoja ajaessasi.
	Mix lukee oikean konfiguraatiotiedoston sen mukaisesti.

	Ohessa enimmäkseen toimivaksi todettu rc.d-skripti pleroman käynnistämiseen.
	Kirjoita se tiedostoon /etc/rc.d/pleroma. Tämän jälkeen aja
	`# chmod +x /etc/rc.d/pleroma`, ja voit käynnistää pleroman komennolla
	`# /etc/rc.d/pleroma start`.

	```
	#!/bin/ksh
	#/etc/rc.d/pleroma

	daemon="cd /home/pleroma/pleroma;MIX_ENV=prod /usr/local/bin/elixir"
	daemon_flags="--detached /usr/local/bin/mix phx.server"
	daemon_user="pleroma"
	rc_reload="NO"
	rc_bg="YES"

	pexp="beam"

	. /etc/rc.d/rc.subr

	rc_cmd $1
	```

	Tämän jälkeen tarvitset enää HTTP-serverin välittämään kutsut pleroma-prosessille.
	Tiedostosta `install/pleroma.nginx` löytyy esimerkkikonfiguraatio, ja TLS-sertifikaatit
	saat ilmaiseksi esimerkiksi [letsencryptiltä](https://certbot.eff.org/lets-encrypt/opbsd-nginx.html).
	Nginx asentuu yksinkertaisesti komennolla `# pkg_add nginx`.

	Kun olet valmis, avaa https://esimerkki.com selaimessasi. Luo käyttäjä ja seuraa kiinnostavia
	tyyppejä muilla palvelimilla!
	diff --git a/installation/openldap/pw_self_service.ldif b/installation/openldap/pw_self_service.ldif
	new file mode 100644
	index 000000000..463dabbfb
	--- /dev/null
	+++ b/installation/openldap/pw_self_service.ldif
	@@ -0,0 +1,7 @@
	+dn: olcDatabase={1}mdb,cn=config
	+changetype: modify
	+add: olcAccess
	+olcAccess: {1}to attrs=userPassword
	+ by self write
	+ by anonymous auth
	+ by * none
	diff --git a/lib/pleroma/constants.ex b/lib/pleroma/constants.ex
	index 5268ebe7a..2828c79a9 100644
	--- a/lib/pleroma/constants.ex
	+++ b/lib/pleroma/constants.ex
	@@ -1,140 +1,145 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Constants do
	use Const

	const(as_public, do: "https://www.w3.org/ns/activitystreams#Public")

	const(object_internal_fields,
	do: [
	"reactions",
	"reaction_count",
	"likes",
	"like_count",
	"announcements",
	"announcement_count",
	"emoji",
	"context_id",
	"deleted_activity_id",
	"pleroma_internal",
	"generator",
	"rules"
	]
	)

	const(static_only_files,
	do:
	~w(index.html robots.txt static static-fe finmoji emoji packs sounds images instance sw.js sw-pleroma.js favicon.png schemas doc embed.js embed.css)
	)

	const(status_updatable_fields,
	do: [
	"source",
	"tag",
	"updated",
	"emoji",
	"content",
	"summary",
	"sensitive",
	"attachment",
	"generator"
	]
	)

	const(status_object_types,
	do: [
	"Note",
	"Question",
	"Audio",
	"Video",
	"Event",
	"Article",
	"Page"
	]
	)

	const(updatable_object_types,
	do: [
	"Note",
	"Question",
	"Audio",
	"Video",
	"Event",
	"Article",
	"Page"
	]
	)

	const(actor_types,
	do: [
	"Application",
	"Group",
	"Organization",
	"Person",
	"Service"
	]
	)

	const(allowed_user_actor_types,
	do: [
	"Person",
	"Service",
	"Group"
	]
	)

	const(activity_types,
	do: [
	+ "Block",
	"Create",
	"Update",
	"Delete",
	"Follow",
	"Accept",
	"Reject",
	"Add",
	"Remove",
	"Like",
	"Announce",
	"Undo",
	"Flag",
	"EmojiReact"
	]
	)

	const(allowed_activity_types_from_strangers,
	do: [
	"Block",
	"Create",
	"Flag",
	"Follow",
	"Like",
	"EmojiReact",
	"Announce"
	]
	)

	+ const(object_types,
	+ do: ~w[Event Question Answer Audio Video Image Article Note Page ChatMessage]
	+ )
	+
	# basic regex, just there to weed out potential mistakes
	# https://datatracker.ietf.org/doc/html/rfc2045#section-5.1
	const(mime_regex,
	do: ~r/^[^[:cntrl:] ()<>@,;:\\"\/\[\]?=]+\/[^[:cntrl:] ()<>@,;:\\"\/\[\]?=]+(; .*)?$/
	)

	const(upload_object_types, do: ["Document", "Image"])

	const(activity_json_canonical_mime_type,
	do: "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)

	const(activity_json_mime_types,
	do: [
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"application/activity+json"
	]
	)

	const(public_streams,
	do: ["public", "public:local", "public:media", "public:local:media"]
	)
	end
	diff --git a/lib/pleroma/ldap.ex b/lib/pleroma/ldap.ex
	index 46a2d0c17..b591c2918 100644
	--- a/lib/pleroma/ldap.ex
	+++ b/lib/pleroma/ldap.ex
	@@ -1,245 +1,271 @@
	defmodule Pleroma.LDAP do
	use GenServer

	require Logger

	alias Pleroma.Config
	alias Pleroma.User

	import Pleroma.Web.Auth.Helpers, only: [fetch_user: 1]

	@connection_timeout 2_000
	@search_timeout 2_000

	def start_link(_) do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	+ def bind_user(name, password) do
	+ GenServer.call(__MODULE__, {:bind_user, name, password})
	+ end
	+
	+ def change_password(name, password, new_password) do
	+ GenServer.call(__MODULE__, {:change_password, name, password, new_password})
	+ end
	+
	@impl true
	def init(state) do
	case {Config.get(Pleroma.Web.Auth.Authenticator), Config.get([:ldap, :enabled])} do
	{Pleroma.Web.Auth.LDAPAuthenticator, true} ->
	{:ok, state, {:continue, :connect}}

	{Pleroma.Web.Auth.LDAPAuthenticator, false} ->
	Logger.error(
	"LDAP Authenticator enabled but :pleroma, :ldap is not enabled. Auth will not work."
	)

	{:ok, state}

	{_, true} ->
	Logger.warning(
	":pleroma, :ldap is enabled but Pleroma.Web.Authenticator is not set to the LDAPAuthenticator. LDAP will not be used."
	)

	{:ok, state}

	_ ->
	{:ok, state}
	end
	end

	@impl true
	def handle_continue(:connect, _state), do: do_handle_connect()

	@impl true
	def handle_info(:connect, _state), do: do_handle_connect()

	def handle_info({:bind_after_reconnect, name, password, from}, state) do
	- result = bind_user(state[:handle], name, password)
	+ result = do_bind_user(state[:handle], name, password)

	GenServer.reply(from, result)

	{:noreply, state}
	end

	- defp do_handle_connect do
	- state =
	- case connect() do
	- {:ok, handle} ->
	- :eldap.controlling_process(handle, self())
	- Process.link(handle)
	- [handle: handle]
	-
	- _ ->
	- Logger.error("Failed to connect to LDAP. Retrying in 5000ms")
	- Process.send_after(self(), :connect, 5_000)
	- []
	- end
	-
	- {:noreply, state}
	- end
	-
	@impl true
	def handle_call({:bind_user, name, password}, from, state) do
	- case bind_user(state[:handle], name, password) do
	+ case do_bind_user(state[:handle], name, password) do
	:needs_reconnect ->
	Process.send(self(), {:bind_after_reconnect, name, password, from}, [])
	{:noreply, state, {:continue, :connect}}

	result ->
	{:reply, result, state, :hibernate}
	end
	end

	+ def handle_call({:change_password, name, password, new_password}, _from, state) do
	+ result = change_password(state[:handle], name, password, new_password)
	+
	+ {:reply, result, state, :hibernate}
	+ end
	+
	@impl true
	def terminate(_, state) do
	handle = Keyword.get(state, :handle)

	if not is_nil(handle) do
	:eldap.close(handle)
	end

	:ok
	end

	- def bind_user(name, password) do
	- GenServer.call(__MODULE__, {:bind_user, name, password})
	+ defp do_handle_connect do
	+ state =
	+ case connect() do
	+ {:ok, handle} ->
	+ :eldap.controlling_process(handle, self())
	+ Process.link(handle)
	+ [handle: handle]
	+
	+ _ ->
	+ Logger.error("Failed to connect to LDAP. Retrying in 5000ms")
	+ Process.send_after(self(), :connect, 5_000)
	+ []
	+ end
	+
	+ {:noreply, state}
	end

	defp connect do
	ldap = Config.get(:ldap, [])
	host = Keyword.get(ldap, :host, "localhost")
	port = Keyword.get(ldap, :port, 389)
	ssl = Keyword.get(ldap, :ssl, false)
	tls = Keyword.get(ldap, :tls, false)
	cacertfile = Keyword.get(ldap, :cacertfile) \|\| CAStore.file_path()

	if ssl, do: Application.ensure_all_started(:ssl)

	default_secure_opts = [
	verify: :verify_peer,
	cacerts: decode_certfile(cacertfile),
	customize_hostname_check: [
	fqdn_fun: fn _ -> to_charlist(host) end
	]
	]

	sslopts = Keyword.merge(default_secure_opts, Keyword.get(ldap, :sslopts, []))
	tlsopts = Keyword.merge(default_secure_opts, Keyword.get(ldap, :tlsopts, []))

	default_options = [{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}]

	# :sslopts can only be included in :eldap.open/2 when {ssl: true}
	# or the connection will fail
	options =
	if ssl do
	default_options ++ [{:sslopts, sslopts}]
	else
	default_options
	end

	case :eldap.open([to_charlist(host)], options) do
	{:ok, handle} ->
	try do
	cond do
	tls ->
	case :eldap.start_tls(
	handle,
	tlsopts,
	@connection_timeout
	) do
	:ok ->
	{:ok, handle}

	error ->
	Logger.error("Could not start TLS: #{inspect(error)}")
	:eldap.close(handle)
	end

	true ->
	{:ok, handle}
	end
	after
	:ok
	end

	{:error, error} ->
	Logger.error("Could not open LDAP connection: #{inspect(error)}")
	{:error, {:ldap_connection_error, error}}
	end
	end

	- defp bind_user(handle, name, password) do
	- uid = Config.get([:ldap, :uid], "cn")
	- base = Config.get([:ldap, :base])
	+ defp do_bind_user(handle, name, password) do
	+ dn = make_dn(name)

	- case :eldap.simple_bind(handle, "#{uid}=#{name},#{base}", password) do
	+ case :eldap.simple_bind(handle, dn, password) do
	:ok ->
	case fetch_user(name) do
	%User{} = user ->
	user

	_ ->
	- register_user(handle, base, uid, name)
	+ register_user(handle, ldap_base(), ldap_uid(), name)
	end

	# eldap does not inform us of socket closure
	# until it is used
	{:error, {:gen_tcp_error, :closed}} ->
	:eldap.close(handle)
	:needs_reconnect

	{:error, error} = e ->
	Logger.error("Could not bind LDAP user #{name}: #{inspect(error)}")
	e
	end
	end

	defp register_user(handle, base, uid, name) do
	case :eldap.search(handle, [
	{:base, to_charlist(base)},
	{:filter, :eldap.equalityMatch(to_charlist(uid), to_charlist(name))},
	{:scope, :eldap.wholeSubtree()},
	{:timeout, @search_timeout}
	]) do
	# The :eldap_search_result record structure changed in OTP 24.3 and added a controls field
	# https://github.com/erlang/otp/pull/5538
	{:ok, {:eldap_search_result, [{:eldap_entry, _object, attributes}], _referrals}} ->
	try_register(name, attributes)

	{:ok, {:eldap_search_result, [{:eldap_entry, _object, attributes}], _referrals, _controls}} ->
	try_register(name, attributes)

	error ->
	Logger.error("Couldn't register user because LDAP search failed: #{inspect(error)}")
	{:error, {:ldap_search_error, error}}
	end
	end

	defp try_register(name, attributes) do
	mail_attribute = Config.get([:ldap, :mail])

	params = %{
	name: name,
	nickname: name,
	password: nil
	}

	params =
	case List.keyfind(attributes, to_charlist(mail_attribute), 0) do
	{_, [mail]} -> Map.put_new(params, :email, :erlang.list_to_binary(mail))
	_ -> params
	end

	changeset = User.register_changeset_ldap(%User{}, params)

	case User.register(changeset) do
	{:ok, user} -> user
	error -> error
	end
	end

	+ defp change_password(handle, name, password, new_password) do
	+ dn = make_dn(name)
	+
	+ with :ok <- :eldap.simple_bind(handle, dn, password) do
	+ :eldap.modify_password(handle, dn, to_charlist(new_password), to_charlist(password))
	+ end
	+ end
	+
	defp decode_certfile(file) do
	with {:ok, data} <- File.read(file) do
	data
	\|> :public_key.pem_decode()
	\|> Enum.map(fn {_, b, _} -> b end)
	else
	_ ->
	Logger.error("Unable to read certfile: #{file}")
	[]
	end
	end
	+
	+ defp ldap_uid, do: to_charlist(Config.get([:ldap, :uid], "cn"))
	+ defp ldap_base, do: to_charlist(Config.get([:ldap, :base]))
	+
	+ defp make_dn(name) do
	+ uid = ldap_uid()
	+ base = ldap_base()
	+ ~c"#{uid}=#{name},#{base}"
	+ end
	end
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index 748f18e6c..77dfda851 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,507 +1,486 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object do
	use Ecto.Schema

	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Hashtag
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.ObjectTombstone
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Workers.AttachmentsCleanupWorker

	require Logger

	@type t() :: %__MODULE__{}

	@derive {Jason.Encoder, only: [:data]}

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

	schema "objects" do
	field(:data, :map)

	many_to_many(:hashtags, Hashtag, join_through: "hashtags_objects", on_replace: :delete)

	timestamps()
	end

	def with_joined_activity(query, activity_type \\ "Create", join_type \\ :inner) do
	object_position = Map.get(query.aliases, :object, 0)

	join(query, join_type, [{object, object_position}], a in Activity,
	on:
	fragment(
	"associated_object_id(?) = (? ->> 'id') AND (?->>'type' = ?) ",
	a.data,
	object.data,
	a.data,
	^activity_type
	),
	as: :object_activity
	)
	end

	def create(data) do
	%Object{}
	\|> Object.change(%{data: data})
	\|> Repo.insert()
	end

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :objects_unique_apid_index)
	# Expecting `maybe_handle_hashtags_change/1` to run last:
	\|> maybe_handle_hashtags_change(struct)
	end

	# Note: not checking activity type (assuming non-legacy objects are associated with Create act.)
	defp maybe_handle_hashtags_change(changeset, struct) do
	with %Ecto.Changeset{valid?: true} <- changeset,
	data_hashtags_change = get_change(changeset, :data),
	{_, true} <- {:changed, hashtags_changed?(struct, data_hashtags_change)},
	{:ok, hashtag_records} <-
	data_hashtags_change
	\|> object_data_hashtags()
	\|> Hashtag.get_or_create_by_names() do
	put_assoc(changeset, :hashtags, hashtag_records)
	else
	%{valid?: false} ->
	changeset

	{:changed, false} ->
	changeset

	{:error, _} ->
	validate_change(changeset, :data, fn _, _ ->
	[data: "error referencing hashtags"]
	end)
	end
	end

	defp hashtags_changed?(%Object{} = struct, %{"tag" => _} = data) do
	Enum.sort(embedded_hashtags(struct)) !=
	Enum.sort(object_data_hashtags(data))
	end

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

	def get_by_id(nil), do: nil
	def get_by_id(id), do: Repo.get(Object, id)

	- @spec get_by_id_and_maybe_refetch(integer(), list()) :: Object.t() \| nil
	- def get_by_id_and_maybe_refetch(id, opts \\ []) do
	- with %Object{updated_at: updated_at} = object <- get_by_id(id) do
	- if opts[:interval] &&
	- NaiveDateTime.diff(NaiveDateTime.utc_now(), updated_at) > opts[:interval] do
	- case Fetcher.refetch_object(object) do
	- {:ok, %Object{} = object} ->
	- object
	-
	- e ->
	- Logger.error("Couldn't refresh #{object.data["id"]}:\n#{inspect(e)}")
	- object
	- end
	- else
	- object
	- end
	- else
	- nil -> nil
	- end
	- end
	-
	def get_by_ap_id(nil), do: nil

	def get_by_ap_id(ap_id) do
	Repo.one(from(object in Object, where: fragment("(?)->>'id' = ?", object.data, ^ap_id)))
	end

	@doc """
	Get a single attachment by it's name and href
	"""
	@spec get_attachment_by_name_and_href(String.t(), String.t()) :: Object.t() \| nil
	def get_attachment_by_name_and_href(name, href) do
	query =
	from(o in Object,
	where: fragment("(?)->>'name' = ?", o.data, ^name),
	where: fragment("(?)->>'href' = ?", o.data, ^href)
	)

	Repo.one(query)
	end

	defp warn_on_no_object_preloaded(ap_id) do
	"Object.normalize() called without preloaded object (#{inspect(ap_id)}). Consider preloading the object"
	\|> Logger.debug()

	Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")
	end

	def normalize(_, options \\ [fetch: false, id_only: false])

	# If we pass an Activity to Object.normalize(), we can try to use the preloaded object.
	# Use this whenever possible, especially when walking graphs in an O(N) loop!
	def normalize(%Object{} = object, _), do: object
	def normalize(%Activity{object: %Object{} = object}, _), do: object

	# A hack for fake activities
	def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}, _) do
	%Object{id: "pleroma:fake_object_id", data: data}
	end

	# No preloaded object
	def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, options) do
	warn_on_no_object_preloaded(ap_id)
	normalize(ap_id, options)
	end

	# No preloaded object
	def normalize(%Activity{data: %{"object" => ap_id}}, options) do
	warn_on_no_object_preloaded(ap_id)
	normalize(ap_id, options)
	end

	# Old way, try fetching the object through cache.
	def normalize(%{"id" => ap_id}, options), do: normalize(ap_id, options)

	def normalize(ap_id, options) when is_binary(ap_id) do
	cond do
	Keyword.get(options, :id_only) ->
	ap_id

	Keyword.get(options, :fetch) ->
	case Fetcher.fetch_object_from_id(ap_id, options) do
	{:ok, object} -> object
	_ -> nil
	end

	true ->
	get_cached_by_ap_id(ap_id)
	end
	end

	def normalize(_, _), do: nil

	# Owned objects can only be accessed by their owner
	def authorize_access(%Object{data: %{"actor" => actor}}, %User{ap_id: ap_id}) do
	if actor == ap_id do
	:ok
	else
	{:error, :forbidden}
	end
	end

	# Legacy objects can be accessed by anybody
	def authorize_access(%Object{}, %User{}), do: :ok

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

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

	def make_tombstone(%Object{data: %{"id" => id, "type" => type}}, deleted \\ DateTime.utc_now()) do
	%ObjectTombstone{
	id: id,
	formerType: type,
	deleted: deleted
	}
	\|> Map.from_struct()
	end

	def swap_object_with_tombstone(object) do
	tombstone = make_tombstone(object)

	with {:ok, object} <-
	object
	\|> Object.change(%{data: tombstone})
	\|> Repo.update() do
	Hashtag.unlink(object)
	{:ok, object}
	end
	end

	def delete(%Object{data: %{"id" => id}} = object) do
	with {:ok, _obj} = swap_object_with_tombstone(object),
	deleted_activity = Activity.delete_all_by_object_ap_id(id),
	{:ok, _} <- invalid_object_cache(object) do
	cleanup_attachments(
	Config.get([:instance, :cleanup_attachments]),
	object
	)

	{:ok, object, deleted_activity}
	end
	end

	@spec cleanup_attachments(boolean(), Object.t()) ::
	{:ok, Oban.Job.t() \| nil}
	def cleanup_attachments(true, %Object{} = object) do
	AttachmentsCleanupWorker.new(%{"op" => "cleanup_attachments", "object" => object})
	\|> Oban.insert()
	end

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

	def prune(%Object{data: %{"id" => _id}} = object) do
	with {:ok, object} <- Repo.delete(object),
	{:ok, _} <- invalid_object_cache(object) do
	{:ok, object}
	end
	end

	def invalid_object_cache(%Object{data: %{"id" => id}}) do
	with {:ok, true} <- @cachex.del(:object_cache, "object:#{id}") do
	@cachex.del(:web_resp_cache, URI.parse(id).path)
	end
	end

	def set_cache(%Object{data: %{"id" => ap_id}} = object) do
	@cachex.put(:object_cache, "object:#{ap_id}", object)
	{:ok, object}
	end

	def update_and_set_cache(changeset) do
	with {:ok, object} <- Repo.update(changeset) do
	set_cache(object)
	end
	end

	def increase_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{repliesCount}',
	(coalesce((?->>'repliesCount')::int, 0) + 1)::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	defp poll_is_multiple?(%Object{data: %{"anyOf" => [_ \| _]}}), do: true

	defp poll_is_multiple?(_), do: false

	def decrease_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{repliesCount}',
	(greatest(0, (?->>'repliesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def increase_quotes_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{quotesCount}',
	(coalesce((?->>'quotesCount')::int, 0) + 1)::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def decrease_quotes_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	safe_jsonb_set(?, '{quotesCount}',
	(greatest(0, (?->>'quotesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def increase_vote_count(ap_id, name, actor) do
	with %Object{} = object <- Object.normalize(ap_id, fetch: false),
	"Question" <- object.data["type"] do
	key = if poll_is_multiple?(object), do: "anyOf", else: "oneOf"

	options =
	object.data[key]
	\|> Enum.map(fn
	%{"name" => ^name} = option ->
	Kernel.update_in(option["replies"]["totalItems"], &(&1 + 1))

	option ->
	option
	end)

	voters = [actor \| object.data["voters"] \|\| []] \|> Enum.uniq()

	data =
	object.data
	\|> Map.put(key, options)
	\|> Map.put("voters", voters)

	object
	\|> Object.change(%{data: data})
	\|> update_and_set_cache()
	else
	_ -> :noop
	end
	end

	@doc "Updates data field of an object"
	def update_data(%Object{data: data} = object, attrs \\ %{}) do
	object
	\|> Object.change(%{data: Map.merge(data \|\| %{}, attrs)})
	\|> Repo.update()
	end

	def local?(%Object{data: %{"id" => id}}) do
	String.starts_with?(id, Pleroma.Web.Endpoint.url() <> "/")
	end

	def replies(object, opts \\ []) do
	object = Object.normalize(object, fetch: false)

	query =
	Object
	\|> where(
	[o],
	fragment("(?)->>'inReplyTo' = ?", o.data, ^object.data["id"])
	)
	\|> order_by([o], asc: o.id)

	if opts[:self_only] do
	actor = object.data["actor"]
	where(query, [o], fragment("(?)->>'actor' = ?", o.data, ^actor))
	else
	query
	end
	end

	def self_replies(object, opts \\ []),
	do: replies(object, Keyword.put(opts, :self_only, true))

	def tags(%Object{data: %{"tag" => tags}}) when is_list(tags), do: tags

	def tags(_), do: []

	def hashtags(%Object{} = object) do
	# Note: always using embedded hashtags regardless whether they are migrated to hashtags table
	# (embedded hashtags stay in sync anyways, and we avoid extra joins and preload hassle)
	embedded_hashtags(object)
	end

	def embedded_hashtags(%Object{data: data}) do
	object_data_hashtags(data)
	end

	def embedded_hashtags(_), do: []

	def object_data_hashtags(%{"tag" => tags}) when is_list(tags) do
	tags
	\|> Enum.filter(fn
	%{"type" => "Hashtag"} = data -> Map.has_key?(data, "name")
	plain_text when is_bitstring(plain_text) -> true
	_ -> false
	end)
	\|> Enum.map(fn
	%{"name" => "#" <> hashtag} -> String.downcase(hashtag)
	%{"name" => hashtag} -> String.downcase(hashtag)
	hashtag when is_bitstring(hashtag) -> String.downcase(hashtag)
	end)
	\|> Enum.uniq()
	# Note: "" elements (plain text) might occur in `data.tag` for incoming objects
	\|> Enum.filter(&(&1 not in [nil, ""]))
	end

	def object_data_hashtags(_), do: []

	def get_emoji_reactions(object) do
	reactions = object.data["reactions"]

	if is_list(reactions) or is_map(reactions) do
	reactions
	\|> Enum.map(fn
	[_emoji, users, _maybe_url] = item when is_list(users) ->
	item

	[emoji, users] when is_list(users) ->
	[emoji, users, nil]

	# This case is here to process the Map situation, which will happen
	# only with the legacy two-value format.
	{emoji, users} when is_list(users) ->
	[emoji, users, nil]

	_ ->
	nil
	end)
	\|> Enum.reject(&is_nil/1)
	else
	[]
	end
	end
	end
	diff --git a/lib/pleroma/object/fetcher.ex b/lib/pleroma/object/fetcher.ex
	index 69a5f3268..c85a8b09f 100644
	--- a/lib/pleroma/object/fetcher.ex
	+++ b/lib/pleroma/object/fetcher.ex
	@@ -1,215 +1,219 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object.Fetcher do
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.Maps
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Signature
	alias Pleroma.Web.ActivityPub.InternalFetchActor
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Federator

	require Logger
	require Pleroma.Constants

	@spec reinject_object(struct(), map()) :: {:ok, Object.t()} \| {:error, any()}
	defp reinject_object(%Object{data: %{}} = object, new_data) do
	Logger.debug("Reinjecting object #{new_data["id"]}")

	with {:ok, new_data, _} <- ObjectValidator.validate(new_data, %{}),
	{:ok, new_data} <- MRF.filter(new_data),
	{:ok, new_object, _} <-
	Object.Updater.do_update_and_invalidate_cache(
	object,
	new_data,
	_touch_changeset? = true
	) do
	{:ok, new_object}
	else
	e ->
	Logger.error("Error while processing object: #{inspect(e)}")
	{:error, e}
	end
	end

	defp reinject_object(_, new_data) do
	with {:ok, object, _} <- Pipeline.common_pipeline(new_data, local: false) do
	{:ok, object}
	else
	e -> e
	end
	end

	def refetch_object(%Object{data: %{"id" => id}} = object) do
	with {:local, false} <- {:local, Object.local?(object)},
	{:ok, new_data} <- fetch_and_contain_remote_object_from_id(id),
	{:ok, object} <- reinject_object(object, new_data) do
	{:ok, object}
	else
	{:local, true} -> {:ok, object}
	e -> {:error, e}
	end
	end

	@typep fetcher_errors ::
	:error \| :reject \| :allowed_depth \| :fetch \| :containment \| :transmogrifier

	# Note: will create a Create activity, which we need internally at the moment.
	@spec fetch_object_from_id(String.t(), list()) ::
	{:ok, Object.t()} \| {fetcher_errors(), any()} \| Pipeline.errors()
	def fetch_object_from_id(id, options \\ []) do
	with {_, nil} <- {:fetch_object, Object.get_cached_by_ap_id(id)},
	{_, true} <- {:allowed_depth, Federator.allowed_thread_distance?(options[:depth])},
	{_, {:ok, data}} <- {:fetch, fetch_and_contain_remote_object_from_id(id)},
	{_, nil} <- {:normalize, Object.normalize(data, fetch: false)},
	params <- prepare_activity_params(data),
	{_, :ok} <- {:containment, Containment.contain_origin(id, params)},
	{_, {:ok, activity}} <-
	{:transmogrifier, Transmogrifier.handle_incoming(params, options)},
	{_, _data, %Object{} = object} <-
	{:object, data, Object.normalize(activity, fetch: false)} do
	{:ok, object}
	else
	{:normalize, object = %Object{}} ->
	{:ok, object}

	{:fetch_object, %Object{} = object} ->
	{:ok, object}

	{:object, data, nil} ->
	reinject_object(%Object{}, data)

	e ->
	Logger.metadata(object: id)
	Logger.error("Object rejected while fetching #{id} #{inspect(e)}")
	e
	end
	end

	defp prepare_activity_params(data) do
	%{
	"type" => "Create",
	# Should we seriously keep this attributedTo thing?
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	}
	\|> Maps.put_if_present("to", data["to"])
	\|> Maps.put_if_present("cc", data["cc"])
	\|> Maps.put_if_present("bto", data["bto"])
	\|> Maps.put_if_present("bcc", data["bcc"])
	end

	defp make_signature(id, date) do
	uri = URI.parse(id)

	signature =
	InternalFetchActor.get_actor()
	\|> Signature.sign(%{
	"(request-target)": "get #{uri.path}",
	host: uri.host,
	date: date
	})

	{"signature", signature}
	end

	defp sign_fetch(headers, id, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[make_signature(id, date) \| headers]
	else
	headers
	end
	end

	defp maybe_date_fetch(headers, date) do
	if Pleroma.Config.get([:activitypub, :sign_object_fetches]) do
	[{"date", date} \| headers]
	else
	headers
	end
	end

	def fetch_and_contain_remote_object_from_id(id)

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

	def fetch_and_contain_remote_object_from_id(id) when is_binary(id) do
	Logger.debug("Fetching object #{id} via AP")

	with {:scheme, true} <- {:scheme, String.starts_with?(id, "http")},
	+ {_, true} <- {:mrf, MRF.id_filter(id)},
	{:ok, body} <- get_object(id),
	{:ok, data} <- safe_json_decode(body),
	:ok <- Containment.contain_origin_from_id(id, data) do
	if not Instances.reachable?(id) do
	Instances.set_reachable(id)
	end

	{:ok, data}
	else
	{:scheme, _} ->
	{:error, "Unsupported URI scheme"}

	{:error, e} ->
	{:error, e}

	+ {:mrf, false} ->
	+ {:error, {:reject, "Filtered by id"}}
	+
	e ->
	{:error, e}
	end
	end

	def fetch_and_contain_remote_object_from_id(_id),
	do: {:error, "id must be a string"}

	defp get_object(id) do
	date = Pleroma.Signature.signed_date()

	headers =
	[{"accept", "application/activity+json"}]
	\|> maybe_date_fetch(date)
	\|> sign_fetch(id, date)

	case HTTP.get(id, headers) do
	{:ok, %{body: body, status: code, headers: headers}} when code in 200..299 ->
	case List.keyfind(headers, "content-type", 0) do
	{_, content_type} ->
	case Plug.Conn.Utils.media_type(content_type) do
	{:ok, "application", "activity+json", _} ->
	{:ok, body}

	{:ok, "application", "ld+json",
	%{"profile" => "https://www.w3.org/ns/activitystreams"}} ->
	{:ok, body}

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

	_ ->
	{:error, {:content_type, nil}}
	end

	{:ok, %{status: code}} when code in [401, 403] ->
	{:error, :forbidden}

	{:ok, %{status: code}} when code in [404, 410] ->
	{:error, :not_found}

	{:error, e} ->
	{:error, e}

	e ->
	{:error, e}
	end
	end

	defp safe_json_decode(nil), do: {:ok, nil}
	defp safe_json_decode(json), do: Jason.decode(json)
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 517009253..7a36ece77 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2859 +1,2864 @@
	# 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.HTML
	alias Pleroma.Keys
	alias Pleroma.MFA
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.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.ObjectID}, 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)

	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 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 status account"
	@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)

	params =
	if Map.has_key?(params, :email) do
	Map.put_new(params, :email, params[:email])
	else
	params
	end

	struct
	\|> cast(params, [
	:name,
	:nickname,
	:email,
	:accepts_chat_messages
	])
	\|> validate_required([:name, :nickname])
	\|> unique_constraint(:nickname)
	\|> validate_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

	def 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

	def maybe_validate_required_email(changeset, true), do: changeset

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

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

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

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

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

	def needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) ::
	{:ok, User.t(), 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
	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(%User{} = blocker, %User{} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

	# clear any requested follows 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)
	add_to_block(blocker, blocked)
	end

	# helper to handle the block given only an actor's AP id
	def block(%User{} = blocker, %{ap_id: ap_id}) do
	block(blocker, get_cached_by_ap_id(ap_id))
	end

	def unblock(%User{} = blocker, %User{} = blocked) do
	remove_from_block(blocker, blocked)
	end

	# helper to handle the block given only an actor's AP id
	def unblock(%User{} = blocker, %{ap_id: ap_id}) do
	unblock(blocker, get_cached_by_ap_id(ap_id))
	end

	def 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()
	def purge_user_changeset(user) do
	# "Right to be forgotten"
	# https://gdpr.eu/right-to-be-forgotten/
	change(user, %{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	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

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

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

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

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

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

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

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

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

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

	def fetch_by_ap_id(ap_id), 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_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 `deactivate/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

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

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

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

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

	defp valid_field?(_), do: false

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

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

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

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

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

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

	@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()) ::
	{:ok, UserRelationship.t()} \| {:error, Ecto.Changeset.t()}
	defp add_to_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.create_block(user, blocked) 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
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index a2a94a0ff..df8795fe4 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1867 +1,1874 @@
	# 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.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Activity.Ir.Topics
	alias Pleroma.Config
	alias Pleroma.Constants
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation
	alias Pleroma.Filter
	alias Pleroma.Hashtag
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.Upload
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Streamer
	alias Pleroma.Web.WebFinger
	alias Pleroma.Workers.BackgroundWorker
	alias Pleroma.Workers.PollWorker

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

	require Logger
	require Pleroma.Constants

	@behaviour Pleroma.Web.ActivityPub.ActivityPub.Persisting
	@behaviour Pleroma.Web.ActivityPub.ActivityPub.Streaming

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

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

	defp check_actor_can_insert(%{"type" => "Delete"}), do: true
	defp check_actor_can_insert(%{"type" => "Undo"}), do: true

	defp check_actor_can_insert(%{"actor" => actor}) when is_binary(actor) do
	case User.get_cached_by_ap_id(actor) do
	%User{is_active: true} -> true
	_ -> false
	end
	end

	defp check_actor_can_insert(_), do: true

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

	defp check_remote_limit(_), do: true

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

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

	def update_last_status_at_if_public(actor, object) do
	if public?(object), do: User.update_last_status_at(actor), else: {:ok, actor}
	end

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

	defp increase_replies_count_if_reply(_create_data), do: :noop

	defp increase_quotes_count_if_quote(%{
	"object" => %{"quoteUrl" => quote_ap_id} = object,
	"type" => "Create"
	}) do
	if public?(object) do
	Object.increase_quotes_count(quote_ap_id)
	end
	end

	defp increase_quotes_count_if_quote(_create_data), do: :noop

	@object_types ~w[ChatMessage Question Answer Audio Video Image Event Article Note Page]
	@impl true
	def persist(%{"type" => type} = object, meta) when type in @object_types do
	with {:ok, object} <- Object.create(object) do
	{:ok, object, meta}
	end
	end

	@impl true
	def persist(object, meta) do
	with local <- Keyword.fetch!(meta, :local),
	{recipients, _, _} <- get_recipients(object),
	{:ok, activity} <-
	Repo.insert(%Activity{
	data: object,
	local: local,
	recipients: recipients,
	actor: object["actor"]
	}),
	# TODO: add tests for expired activities, when Note type will be supported in new pipeline
	{:ok, _} <- maybe_create_activity_expiration(activity) do
	{:ok, activity, meta}
	end
	end

	@spec insert(map(), boolean(), boolean(), boolean()) :: {:ok, Activity.t()} \| {:error, any()}
	def insert(map, local \\ true, fake \\ false, bypass_actor_check \\ false) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map, fake),
	{_, true} <- {:actor_check, bypass_actor_check \|\| check_actor_can_insert(map)},
	{_, true} <- {:remote_limit_pass, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	{recipients, _, _} = get_recipients(map),
	{:fake, false, map, recipients} <- {:fake, fake, map, recipients},
	{:containment, :ok} <- {:containment, Containment.contain_child(map)},
	{:ok, map, object} <- insert_full_object(map),
	{:ok, activity} <- insert_activity_with_expiration(map, local, recipients) do
	# Splice in the child object if we have one.
	activity = Maps.put_if_present(activity, :object, object)

	Pleroma.Web.RichMedia.Card.get_by_activity(activity)

	# Add local posts to search index
	if local, do: Pleroma.Search.add_to_index(activity)

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

	{:actor_check, _} ->
	{:error, false}

	{:containment, _} = error ->
	error

	{:error, _} = error ->
	error

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

	Pleroma.Web.RichMedia.Card.get_by_activity(activity)
	{:ok, activity}

	{:remote_limit_pass, _} ->
	{:error, :remote_limit}

	{:reject, _} = e ->
	{:error, e}
	end
	end

	defp insert_activity_with_expiration(data, local, recipients) do
	struct = %Activity{
	data: data,
	local: local,
	actor: data["actor"],
	recipients: recipients
	}

	with {:ok, activity} <- Repo.insert(struct) do
	maybe_create_activity_expiration(activity)
	end
	end

	def notify_and_stream(activity) do
	{:ok, notifications} = Notification.create_notifications(activity)
	Notification.stream(notifications)

	original_activity =
	case activity do
	%{data: %{"type" => "Update"}, object: %{data: %{"id" => id}}} ->
	Activity.get_create_by_object_ap_id_with_object(id)

	_ ->
	activity
	end

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

	defp maybe_create_activity_expiration(
	%{data: %{"expires_at" => %DateTime{} = expires_at}} = activity
	) do
	with {:ok, _job} <-
	Pleroma.Workers.PurgeExpiredActivity.enqueue(
	%{
	activity_id: activity.id
	},
	scheduled_at: expires_at
	) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(activity), do: {:ok, activity}

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

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

	defp get_participations(_), do: []

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

	Streamer.stream("participation", participations)
	end

	@impl true
	def stream_out_participations(%Object{data: %{"context" => context}}, user) do
	with %Conversation{} = conversation <- Conversation.get_for_ap_id(context) do
	conversation = Repo.preload(conversation, :participations)

	last_activity_id =
	fetch_latest_direct_activity_id_for_context(conversation.ap_id, %{
	user: user,
	blocking_user: user
	})

	if last_activity_id do
	stream_out_participations(conversation.participations)
	end
	end
	end

	@impl true
	def stream_out_participations(_, _), do: :noop

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

	@impl true
	def stream_out(_activity) do
	:noop
	end

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

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

	create_data =
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

	with {:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	_ <- increase_quotes_count_if_quote(create_data),
	{:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	{:ok, _actor} <- update_last_status_at_if_public(actor, activity),
	_ <- notify_and_stream(activity),
	:ok <- maybe_schedule_poll_notifications(activity),
	:ok <- maybe_handle_group_posts(activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:quick_insert, true, activity} ->
	{:ok, activity}

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

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

	defp maybe_schedule_poll_notifications(activity) do
	PollWorker.schedule_poll_end(activity)
	:ok
	end

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

	listen_data =
	make_listen_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	)

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

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

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

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

	defp do_flag(
	%{
	actor: actor,
	context: _context,
	account: account,
	statuses: statuses,
	content: content
	} = params
	) do
	# only accept false as false value
	local = !(params[:local] == false)
	forward = !(params[:forward] == false)

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

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

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

	{:ok, activity}
	else
	{:error, error} -> Repo.rollback(error)
	end
	end

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

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

	BackgroundWorker.new(%{
	"op" => "move_following",
	"origin_id" => origin.id,
	"target_id" => target.id
	})
	\|> Oban.insert()

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

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

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

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

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

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

	defp fetch_paginated_optimized(query, opts, pagination) do
	# Note: tag-filtering funcs may apply "ORDER BY objects.id DESC",
	# and extra sorting on "activities.id DESC NULLS LAST" would worse the query plan
	opts = Map.put(opts, :skip_extra_order, true)

	Pagination.fetch_paginated(query, opts, pagination)
	end

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

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

	@spec fetch_public_or_unlisted_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_or_unlisted_activities(opts \\ %{}, pagination \\ :keyset) do
	includes_local_public = Map.get(opts, :includes_local_public, false)

	opts = Map.delete(opts, :user)

	intended_recipients =
	if includes_local_public do
	[Constants.as_public(), as_local_public()]
	else
	[Constants.as_public()]
	end

	intended_recipients
	\|> fetch_activities_query(opts)
	\|> restrict_unlisted(opts)
	\|> fetch_paginated_optimized(opts, pagination)
	end

	@spec fetch_public_activities(map(), Pagination.type()) :: [Activity.t()]
	def fetch_public_activities(opts \\ %{}, pagination \\ :keyset) do
	opts
	\|> Map.put(:restrict_unlisted, true)
	\|> fetch_public_or_unlisted_activities(pagination)
	end

	@valid_visibilities ~w[direct unlisted public private]

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

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

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

	defp restrict_visibility(query, _visibility), do: query

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

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

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

	defp exclude_visibility(query, _visibility), do: query

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

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

	defp restrict_thread_visibility(query, %{user: %User{ap_id: ap_id}}, _) do
	local_public = as_local_public()

	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id', ?) = true", ^ap_id, a.data, ^local_public)
	)
	end

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

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

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params)
	\|> Enum.reverse()
	end

	def fetch_user_activities(user, reading_user, params \\ %{})

	def fetch_user_activities(user, reading_user, %{total: true} = params) do
	result = fetch_activities_for_user(user, reading_user, params)

	Keyword.put(result, :items, Enum.reverse(result[:items]))
	end

	def fetch_user_activities(user, reading_user, params) do
	user
	\|> fetch_activities_for_user(reading_user, params)
	\|> Enum.reverse()
	end

	defp fetch_activities_for_user(user, reading_user, params) do
	params =
	params
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:user, reading_user)
	\|> Map.put(:actor_id, user.ap_id)
	\|> Map.put(:pinned_object_ids, Map.keys(user.pinned_objects))

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

	pagination_type = Map.get(params, :pagination_type) \|\| :keyset

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, pagination_type)
	end

	def fetch_statuses(reading_user, %{total: true} = params) do
	result = fetch_activities_for_reading_user(reading_user, params)
	Keyword.put(result, :items, Enum.reverse(result[:items]))
	end

	def fetch_statuses(reading_user, params) do
	reading_user
	\|> fetch_activities_for_reading_user(params)
	\|> Enum.reverse()
	end

	defp fetch_activities_for_reading_user(reading_user, params) do
	params = Map.put(params, :type, ["Create", "Announce"])

	%{
	godmode: params[:godmode],
	reading_user: reading_user
	}
	\|> user_activities_recipients()
	\|> fetch_activities(params, :offset)
	end

	defp user_activities_recipients(%{godmode: true}), do: []

	defp user_activities_recipients(%{reading_user: reading_user}) do
	if not is_nil(reading_user) and reading_user.local do
	[
	Constants.as_public(),
	as_local_public(),
	reading_user.ap_id \| User.following(reading_user)
	]
	else
	[Constants.as_public()]
	end
	end

	defp restrict_announce_object_actor(_query, %{announce_filtering_user: _, skip_preload: true}) do
	raise "Can't use the child object without preloading!"
	end

	defp restrict_announce_object_actor(query, %{announce_filtering_user: %{ap_id: actor}}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"?->>'type' != ? or ?->>'actor' != ?",
	activity.data,
	"Announce",
	object.data,
	^actor
	)
	)
	end

	defp restrict_announce_object_actor(query, _), do: query

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

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

	defp restrict_since(query, _), do: query

	defp restrict_embedded_tag_all(_query, %{tag_all: _tag_all, skip_preload: true}) do
	raise_on_missing_preload()
	end

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

	defp restrict_embedded_tag_all(query, %{tag_all: tag}) when is_binary(tag) do
	restrict_embedded_tag_any(query, %{tag: tag})
	end

	defp restrict_embedded_tag_all(query, _), do: query

	defp restrict_embedded_tag_any(_query, %{tag: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

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

	defp restrict_embedded_tag_any(query, %{tag: tag}) when is_binary(tag) do
	restrict_embedded_tag_any(query, %{tag: [tag]})
	end

	defp restrict_embedded_tag_any(query, _), do: query

	defp restrict_embedded_tag_reject_any(_query, %{tag_reject: _tag_reject, skip_preload: true}) do
	raise_on_missing_preload()
	end

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

	defp restrict_embedded_tag_reject_any(query, %{tag_reject: tag_reject})
	when is_binary(tag_reject) do
	restrict_embedded_tag_reject_any(query, %{tag_reject: [tag_reject]})
	end

	defp restrict_embedded_tag_reject_any(query, _), do: query

	defp object_ids_query_for_tags(tags) do
	from(hto in "hashtags_objects")
	\|> join(:inner, [hto], ht in Pleroma.Hashtag, on: hto.hashtag_id == ht.id)
	\|> where([hto, ht], ht.name in ^tags)
	\|> select([hto], hto.object_id)
	\|> distinct([hto], true)
	end

	defp restrict_hashtag_all(_query, %{tag_all: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_all(query, %{tag_all: [single_tag]}) do
	restrict_hashtag_any(query, %{tag: single_tag})
	end

	defp restrict_hashtag_all(query, %{tag_all: [_ \| _] = tags}) do
	from(
	[_activity, object] in query,
	where:
	fragment(
	"""
	(SELECT array_agg(hashtags.name) FROM hashtags JOIN hashtags_objects
	ON hashtags_objects.hashtag_id = hashtags.id WHERE hashtags.name = ANY(?)
	AND hashtags_objects.object_id = ?) @> ?
	""",
	^tags,
	object.id,
	^tags
	)
	)
	end

	defp restrict_hashtag_all(query, %{tag_all: tag}) when is_binary(tag) do
	restrict_hashtag_all(query, %{tag_all: [tag]})
	end

	defp restrict_hashtag_all(query, _), do: query

	defp restrict_hashtag_any(_query, %{tag: _tag, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_any(query, %{tag: [_ \| _] = tags}) do
	hashtag_ids =
	from(ht in Hashtag, where: ht.name in ^tags, select: ht.id)
	\|> Repo.all()

	# Note: NO extra ordering should be done on "activities.id desc nulls last" for optimal plan
	from(
	[_activity, object] in query,
	join: hto in "hashtags_objects",
	on: hto.object_id == object.id,
	where: hto.hashtag_id in ^hashtag_ids,
	distinct: [desc: object.id],
	order_by: [desc: object.id]
	)
	end

	defp restrict_hashtag_any(query, %{tag: tag}) when is_binary(tag) do
	restrict_hashtag_any(query, %{tag: [tag]})
	end

	defp restrict_hashtag_any(query, _), do: query

	defp restrict_hashtag_reject_any(_query, %{tag_reject: _tag_reject, skip_preload: true}) do
	raise_on_missing_preload()
	end

	defp restrict_hashtag_reject_any(query, %{tag_reject: [_ \| _] = tags_reject}) do
	from(
	[_activity, object] in query,
	where: object.id not in subquery(object_ids_query_for_tags(tags_reject))
	)
	end

	defp restrict_hashtag_reject_any(query, %{tag_reject: tag_reject}) when is_binary(tag_reject) do
	restrict_hashtag_reject_any(query, %{tag_reject: [tag_reject]})
	end

	defp restrict_hashtag_reject_any(query, _), do: query

	defp raise_on_missing_preload do
	raise "Can't use the child object without preloading!"
	end

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

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

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

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

	defp restrict_local(query, _), do: query

	defp restrict_remote(query, %{remote: true}) do
	from(activity in query, where: activity.local == false)
	end

	defp restrict_remote(query, _), do: query

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

	defp restrict_actor(query, _), do: query

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

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

	defp restrict_type(query, _), do: query

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

	defp restrict_state(query, _), do: query

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

	defp restrict_favorited_by(query, _), do: query

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

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

	defp restrict_media(query, _), do: query

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

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

	defp restrict_replies(query, %{
	reply_filtering_user: %User{} = user,
	reply_visibility: "following"
	}) do
	from(
	[activity, object] in query,
	where:
	fragment(
	"""
	?->>'type' != 'Create' -- This isn't a Create
	OR ?->>'inReplyTo' is null -- this isn't a reply
	OR ? && array_remove(?, ?) -- The recipient is us or one of our friends,
	-- unless they are the author (because authors
	-- are also part of the recipients). This leads
	-- to a bug that self-replies by friends won't
	-- show up.
	OR ? = ? -- The actor is us
	""",
	activity.data,
	object.data,
	^[user.ap_id \| User.get_cached_user_friends_ap_ids(user)],
	activity.recipients,
	activity.actor,
	activity.actor,
	^user.ap_id
	)
	)
	end

	defp restrict_replies(query, _), do: query

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

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{with_muted: true}), do: query

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

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

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

	defp restrict_muted(query, _), do: query

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

	following_ap_ids = User.get_friends_ap_ids(user)

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

	from(
	[activity, object: o] in query,
	# You don't block the author
	where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),

	# You don't block any recipients, and didn't author the post
	where:
	fragment(
	"((not (? && ?)) or ? = ?)",
	activity.recipients,
	^blocked_ap_ids,
	activity.actor,
	^user.ap_id
	),

	# You don't block the domain of any recipients, and didn't author the post
	where:
	fragment(
	"(recipients_contain_blocked_domains(?, ?) = false) or ? = ?",
	activity.recipients,
	^domain_blocks,
	activity.actor,
	^user.ap_id
	),

	# It's not a boost of a user you block
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocked_ap_ids
	),

	# You don't block the author's domain, and also don't follow the author
	where:
	fragment(
	"(not (split_part(?, '/', 3) = ANY(?))) or ? = ANY(?)",
	activity.actor,
	^domain_blocks,
	activity.actor,
	^following_ap_ids
	),

	# Same as above, but checks the Object
	where:
	fragment(
	"(not (split_part(?->>'actor', '/', 3) = ANY(?))) or (?->>'actor') = ANY(?)",
	o.data,
	^domain_blocks,
	o.data,
	^following_ap_ids
	)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_blockers_visibility(query, %{blocking_user: %User{} = user}) do
	if Config.get([:activitypub, :blockers_visible]) == true do
	query
	else
	blocker_ap_ids = User.incoming_relationships_ungrouped_ap_ids(user, [:block])

	from(
	activity in query,
	# The author doesn't block you
	where: fragment("not (? = ANY(?))", activity.actor, ^blocker_ap_ids),

	# It's not a boost of a user that blocks you
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocker_ap_ids
	)
	)
	end
	end

	defp restrict_blockers_visibility(query, _), do: query

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

	defp restrict_unlisted(query, _), do: query

	defp restrict_pinned(query, %{pinned: true, pinned_object_ids: ids}) do
	from(
	[activity, object: o] in query,
	where:
	fragment(
	"(?)->>'type' = 'Create' and associated_object_id((?)) = any (?)",
	activity.data,
	activity.data,
	^ids
	)
	)
	end

	defp restrict_pinned(query, _), do: query

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

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

	defp restrict_muted_reblogs(query, _), do: query

	defp restrict_instance(query, %{instance: instance}) when is_binary(instance) do
	from(
	activity in query,
	where: fragment("split_part(actor::text, '/'::text, 3) = ?", ^instance)
	)
	end

	defp restrict_instance(query, _), do: query

	defp restrict_filtered(query, %{user: %User{} = user}) do
	case Filter.compose_regex(user) do
	nil ->
	query

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

	defp restrict_filtered(query, %{blocking_user: %User{} = user}) do
	restrict_filtered(query, %{user: user})
	end

	defp restrict_filtered(query, _), do: query

	defp restrict_unauthenticated(query, nil) do
	local = Config.restrict_unauthenticated_access?(:activities, :local)
	remote = Config.restrict_unauthenticated_access?(:activities, :remote)

	cond do
	local and remote ->
	from(activity in query, where: false)

	local ->
	from(activity in query, where: activity.local == false)

	remote ->
	from(activity in query, where: activity.local == true)

	true ->
	query
	end
	end

	defp restrict_unauthenticated(query, _), do: query

	defp restrict_quote_url(query, %{quote_url: quote_url}) do
	from([_activity, object] in query,
	where: fragment("(?)->'quoteUrl' = ?", object.data, ^quote_url)
	)
	end

	defp restrict_quote_url(query, _), do: query

	defp restrict_rule(query, %{rule_id: rule_id}) do
	from(
	activity in query,
	where: fragment("(?)->'rules' \\? (?)", activity.data, ^rule_id)
	)
	end

	defp restrict_rule(query, _), do: query

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

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

	defp exclude_chat_messages(query, %{include_chat_messages: true}), do: query

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

	defp exclude_invisible_actors(query, %{type: "Flag"}), do: query
	defp exclude_invisible_actors(query, %{invisible_actors: true}), do: query

	defp exclude_invisible_actors(query, _opts) do
	query
	\|> join(:inner, [activity], u in User,
	as: :u,
	on: activity.actor == u.ap_id and u.invisible == false
	)
	end

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

	defp exclude_id(query, _), do: query

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

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

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

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

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

	defp maybe_preload_report_notes(query, _), do: query

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

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

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

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

	defp maybe_order(query, _), do: query

	defp normalize_fetch_activities_query_opts(opts) do
	Enum.reduce([:tag, :tag_all, :tag_reject], opts, fn key, opts ->
	case opts[key] do
	value when is_bitstring(value) ->
	Map.put(opts, key, Hashtag.normalize_name(value))

	value when is_list(value) ->
	normalized_value =
	value
	\|> Enum.map(&Hashtag.normalize_name/1)
	\|> Enum.uniq()

	Map.put(opts, key, normalized_value)

	_ ->
	opts
	end
	end)
	end

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

	ap_id_relationships =
	if opts[:blocking_user] && opts[:blocking_user] == source_user do
	[:block \| ap_id_relationships]
	else
	ap_id_relationships
	end

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(source_user, ap_id_relationships)

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

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

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts}
	end

	def fetch_activities_query(recipients, opts \\ %{}) do
	opts = normalize_fetch_activities_query_opts(opts)

	{restrict_blocked_opts, restrict_muted_opts, restrict_muted_reblogs_opts} =
	fetch_activities_query_ap_ids_ops(opts)

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

	query =
	Activity
	\|> maybe_preload_objects(opts)
	\|> maybe_preload_bookmarks(opts)
	\|> maybe_preload_report_notes(opts)
	\|> maybe_set_thread_muted_field(opts)
	\|> maybe_order(opts)
	\|> restrict_recipients(recipients, opts[:user])
	\|> restrict_replies(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_remote(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_state(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(restrict_blocked_opts)
	\|> restrict_blockers_visibility(opts)
	\|> restrict_muted(restrict_muted_opts)
	\|> restrict_filtered(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_thread_visibility(opts, config)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(restrict_muted_reblogs_opts)
	\|> restrict_instance(opts)
	\|> restrict_announce_object_actor(opts)
	\|> restrict_filtered(opts)
	\|> restrict_rule(opts)
	\|> restrict_quote_url(opts)
	\|> maybe_restrict_deactivated_users(opts)
	\|> exclude_poll_votes(opts)
	\|> exclude_chat_messages(opts)
	\|> exclude_invisible_actors(opts)
	\|> exclude_visibility(opts)

	if Config.feature_enabled?(:improved_hashtag_timeline) do
	query
	\|> restrict_hashtag_any(opts)
	\|> restrict_hashtag_all(opts)
	\|> restrict_hashtag_reject_any(opts)
	else
	query
	\|> restrict_embedded_tag_any(opts)
	\|> restrict_embedded_tag_all(opts)
	\|> restrict_embedded_tag_reject_any(opts)
	end
	end

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

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

	activity ->
	activity
	end)
	end

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

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

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

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

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

	defp sanitize_upload_file(%Plug.Upload{filename: filename} = upload) when is_binary(filename) do
	%Plug.Upload{
	upload
	\| filename: Path.basename(filename)
	}
	end

	defp sanitize_upload_file(upload), do: upload

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

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

	defp get_actor_url(_url), do: nil

	- defp normalize_image(%{"url" => url}) do
	+ defp normalize_image(%{"url" => url} = data) do
	%{
	"type" => "Image",
	"url" => [%{"href" => url}]
	}
	+ \|> maybe_put_description(data)
	end

	defp normalize_image(urls) when is_list(urls), do: urls \|> List.first() \|> normalize_image()
	defp normalize_image(_), do: nil

	+ defp maybe_put_description(map, %{"name" => description}) when is_binary(description) do
	+ Map.put(map, "name", description)
	+ end
	+
	+ defp maybe_put_description(map, _), do: map
	+
	defp object_to_user_data(data, additional) do
	fields =
	data
	\|> Map.get("attachment", [])
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)

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

	is_locked = data["manuallyApprovesFollowers"] \|\| false
	capabilities = data["capabilities"] \|\| %{}
	accepts_chat_messages = capabilities["acceptsChatMessages"]
	data = Transmogrifier.maybe_fix_user_object(data)
	is_discoverable = data["discoverable"] \|\| false
	invisible = data["invisible"] \|\| false
	actor_type = data["type"] \|\| "Person"

	featured_address = data["featured"]
	{:ok, pinned_objects} = fetch_and_prepare_featured_from_ap_id(featured_address)

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

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

	birthday =
	if is_binary(data["vcard:bday"]) do
	case Date.from_iso8601(data["vcard:bday"]) do
	{:ok, date} -> date
	{:error, _} -> nil
	end
	end

	show_birthday = !!birthday

	# if WebFinger request was already done, we probably have acct, otherwise
	# we request WebFinger here
	nickname = additional[:nickname_from_acct] \|\| generate_nickname(data)

	%{
	ap_id: data["id"],
	uri: get_actor_url(data["url"]),
	banner: normalize_image(data["image"]),
	fields: fields,
	emoji: emojis,
	is_locked: is_locked,
	is_discoverable: is_discoverable,
	invisible: invisible,
	avatar: normalize_image(data["icon"]),
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	featured_address: featured_address,
	bio: data["summary"] \|\| "",
	actor_type: actor_type,
	also_known_as: Map.get(data, "alsoKnownAs", []),
	public_key: public_key,
	inbox: data["inbox"],
	shared_inbox: shared_inbox,
	accepts_chat_messages: accepts_chat_messages,
	birthday: birthday,
	show_birthday: show_birthday,
	pinned_objects: pinned_objects,
	nickname: nickname
	}
	end

	defp generate_nickname(%{"preferredUsername" => username} = data) when is_binary(username) do
	generated = "#{username}@#{URI.parse(data["id"]).host}"

	if Config.get([WebFinger, :update_nickname_on_user_fetch]) do
	case WebFinger.finger(generated) do
	{:ok, %{"subject" => "acct:" <> acct}} -> acct
	_ -> generated
	end
	else
	generated
	end
	end

	# nickname can be nil because of virtual actors
	defp generate_nickname(_), do: nil

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

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

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

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

	{:collections_available, false} ->
	user_data

	{:enabled, false} ->
	user_data

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

	user_data
	end
	end

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

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

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

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

	defp fetch_and_prepare_user_from_ap_id(ap_id, additional) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	{:ok, data} <- user_data_from_user_object(data, additional) do
	{:ok, maybe_update_follow_information(data)}
	else
	# If this has been deleted, only log a debug and not an error
	{:error, "Object has been deleted" = e} ->
	Logger.debug("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	{:error, e}

	{:error, {:reject, reason} = e} ->
	Logger.info("Rejected user #{ap_id}: #{inspect(reason)}")
	{:error, e}

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

	def maybe_handle_clashing_nickname(data) do
	with nickname when is_binary(nickname) <- data[:nickname],
	%User{} = old_user <- User.get_by_nickname(nickname),
	{_, false} <- {:ap_id_comparison, data[:ap_id] == old_user.ap_id} do
	Logger.info(
	"Found an old user for #{nickname}, the old ap id is #{old_user.ap_id}, new one is #{data[:ap_id]}, renaming."
	)

	old_user
	\|> User.remote_user_changeset(%{nickname: "#{old_user.id}.#{old_user.nickname}"})
	\|> User.update_and_set_cache()
	else
	{:ap_id_comparison, true} ->
	Logger.info(
	"Found an old user for #{data[:nickname]}, but the ap id #{data[:ap_id]} is the same as the new user. Race condition? Not changing anything."
	)

	_ ->
	nil
	end
	end

	def pin_data_from_featured_collection(%{
	"type" => type,
	"orderedItems" => objects
	})
	when type in ["OrderedCollection", "Collection"] do
	Map.new(objects, fn
	%{"id" => object_ap_id} -> {object_ap_id, NaiveDateTime.utc_now()}
	object_ap_id when is_binary(object_ap_id) -> {object_ap_id, NaiveDateTime.utc_now()}
	end)
	end

	def pin_data_from_featured_collection(obj) do
	Logger.error("Could not parse featured collection #{inspect(obj)}")
	%{}
	end

	def fetch_and_prepare_featured_from_ap_id(nil) do
	{:ok, %{}}
	end

	def fetch_and_prepare_featured_from_ap_id(ap_id) do
	with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id) do
	{:ok, pin_data_from_featured_collection(data)}
	else
	e ->
	Logger.error("Could not decode featured collection at fetch #{ap_id}, #{inspect(e)}")
	{:ok, %{}}
	end
	end

	def enqueue_pin_fetches(%{pinned_objects: pins}) do
	# enqueue a task to fetch all pinned objects
	Enum.each(pins, fn {ap_id, _} ->
	if is_nil(Object.get_cached_by_ap_id(ap_id)) do
	Pleroma.Workers.RemoteFetcherWorker.new(%{
	"op" => "fetch_remote",
	"id" => ap_id,
	"depth" => 1
	})
	\|> Oban.insert()
	end
	end)
	end

	def enqueue_pin_fetches(_), do: nil

	def make_user_from_ap_id(ap_id, additional \\ []) do
	user = User.get_cached_by_ap_id(ap_id)

	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id, additional) do
	enqueue_pin_fetches(data)

	if user do
	user
	\|> User.remote_user_changeset(data)
	\|> User.update_and_set_cache()
	else
	maybe_handle_clashing_nickname(data)

	data
	\|> User.remote_user_changeset()
	\|> Repo.insert()
	\|> User.set_cache()
	end
	end
	end

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

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

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

	def fetch_direct_messages_query do
	Activity
	\|> restrict_type(%{type: "Create"})
	\|> restrict_visibility(%{visibility: "direct"})
	\|> order_by([activity], asc: activity.id)
	end

	defp maybe_restrict_deactivated_users(activity, %{type: "Flag"}), do: activity

	defp maybe_restrict_deactivated_users(activity, _opts),
	do: Activity.restrict_deactivated_users(activity)
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf.ex b/lib/pleroma/web/activity_pub/mrf.ex
	index bc418d908..51ab476b7 100644
	--- a/lib/pleroma/web/activity_pub/mrf.ex
	+++ b/lib/pleroma/web/activity_pub/mrf.ex
	@@ -1,230 +1,238 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF do
	require Logger

	@behaviour Pleroma.Web.ActivityPub.MRF.PipelineFiltering

	@mrf_config_descriptions [
	%{
	group: :pleroma,
	key: :mrf,
	tab: :mrf,
	label: "MRF",
	type: :group,
	description: "General MRF settings",
	children: [
	%{
	key: :policies,
	type: [:module, {:list, :module}],
	description:
	"A list of MRF policies enabled. Module names are shortened (removed leading `Pleroma.Web.ActivityPub.MRF.` part), but on adding custom module you need to use full name.",
	suggestions: {:list_behaviour_implementations, Pleroma.Web.ActivityPub.MRF.Policy}
	},
	%{
	key: :transparency,
	label: "MRF transparency",
	type: :boolean,
	description:
	"Make the content of your Message Rewrite Facility settings public (via nodeinfo)"
	},
	%{
	key: :transparency_exclusions,
	label: "MRF transparency exclusions",
	type: {:list, :tuple},
	key_placeholder: "instance",
	value_placeholder: "reason",
	description:
	"Exclude specific instance names from MRF transparency. The use of the exclusions feature will be disclosed in nodeinfo as a boolean value. You can also provide a reason for excluding these instance names. The instances and reasons won't be publicly disclosed.",
	suggestions: [
	"exclusion.com"
	]
	}
	]
	}
	]

	@default_description %{
	label: "",
	description: ""
	}

	@required_description_keys [:key, :related_policy]

	def filter_one(policy, message) do
	Code.ensure_loaded(policy)

	should_plug_history? =
	if function_exported?(policy, :history_awareness, 0) do
	policy.history_awareness()
	else
	:manual
	end
	\|> Kernel.==(:auto)

	if not should_plug_history? do
	policy.filter(message)
	else
	main_result = policy.filter(message)

	with {_, {:ok, main_message}} <- {:main, main_result},
	{_,
	%{
	"formerRepresentations" => %{
	"orderedItems" => [_ \| _]
	}
	}} = {_, object} <- {:object, message["object"]},
	{_, {:ok, new_history}} <-
	{:history,
	Pleroma.Object.Updater.for_each_history_item(
	object["formerRepresentations"],
	object,
	fn item ->
	with {:ok, filtered} <- policy.filter(Map.put(message, "object", item)) do
	{:ok, filtered["object"]}
	else
	e -> e
	end
	end
	)} do
	{:ok, put_in(main_message, ["object", "formerRepresentations"], new_history)}
	else
	{:main, _} -> main_result
	{:object, _} -> main_result
	{:history, e} -> e
	end
	end
	end

	def filter(policies, %{} = message) do
	policies
	\|> Enum.reduce({:ok, message}, fn
	policy, {:ok, message} -> filter_one(policy, message)
	_, error -> error
	end)
	end

	def filter(%{} = object), do: get_policies() \|> filter(object)

	+ def id_filter(policies, id) when is_binary(id) do
	+ policies
	+ \|> Enum.filter(&function_exported?(&1, :id_filter, 1))
	+ \|> Enum.all?(& &1.id_filter(id))
	+ end
	+
	+ def id_filter(id) when is_binary(id), do: get_policies() \|> id_filter(id)
	+
	@impl true
	def pipeline_filter(%{} = message, meta) do
	object = meta[:object_data]
	ap_id = message["object"]

	if object && ap_id do
	with {:ok, message} <- filter(Map.put(message, "object", object)) do
	meta = Keyword.put(meta, :object_data, message["object"])
	{:ok, Map.put(message, "object", ap_id), meta}
	else
	{err, message} -> {err, message, meta}
	end
	else
	{err, message} = filter(message)

	{err, message, meta}
	end
	end

	def get_policies do
	Pleroma.Config.get([:mrf, :policies], [])
	\|> get_policies()
	\|> Enum.concat([Pleroma.Web.ActivityPub.MRF.HashtagPolicy])
	end

	defp get_policies(policy) when is_atom(policy), do: [policy]
	defp get_policies(policies) when is_list(policies), do: policies
	defp get_policies(_), do: []

	@spec subdomains_regex([String.t()]) :: [Regex.t()]
	def subdomains_regex(domains) when is_list(domains) do
	for domain <- domains do
	try do
	target = String.replace(domain, ".", "(.\\.)*")
	~r<^#{target}$>i
	rescue
	e ->
	Logger.error("MRF: Invalid subdomain Regex: #{domain}")
	reraise e, __STACKTRACE__
	end
	end
	end

	@spec subdomain_match?([Regex.t()], String.t()) :: boolean()
	def subdomain_match?(domains, host) do
	Enum.any?(domains, fn domain -> Regex.match?(domain, host) end)
	end

	@spec instance_list_from_tuples([{String.t(), String.t()}]) :: [String.t()]
	def instance_list_from_tuples(list) do
	Enum.map(list, fn {instance, _} -> instance end)
	end

	def describe(policies) do
	{:ok, policy_configs} =
	policies
	\|> Enum.reduce({:ok, %{}}, fn
	policy, {:ok, data} ->
	{:ok, policy_data} = policy.describe()
	{:ok, Map.merge(data, policy_data)}

	_, error ->
	error
	end)

	mrf_policies =
	get_policies()
	\|> Enum.map(fn policy -> to_string(policy) \|> String.split(".") \|> List.last() end)

	exclusions = Pleroma.Config.get([:mrf, :transparency_exclusions])

	base =
	%{
	mrf_policies: mrf_policies,
	exclusions: length(exclusions) > 0
	}
	\|> Map.merge(policy_configs)

	{:ok, base}
	end

	def describe, do: get_policies() \|> describe()

	def config_descriptions do
	Pleroma.Web.ActivityPub.MRF.Policy
	\|> Pleroma.Docs.Generator.list_behaviour_implementations()
	\|> config_descriptions()
	end

	def config_descriptions(policies) do
	Enum.reduce(policies, @mrf_config_descriptions, fn policy, acc ->
	Code.ensure_loaded(policy)

	if function_exported?(policy, :config_description, 0) do
	description =
	@default_description
	\|> Map.merge(policy.config_description())
	\|> Map.put(:group, :pleroma)
	\|> Map.put(:tab, :mrf)
	\|> Map.put(:type, :group)

	if Enum.all?(@required_description_keys, &Map.has_key?(description, &1)) do
	[description \| acc]
	else
	Logger.warning(
	"#{policy} config description doesn't have one or all required keys #{inspect(@required_description_keys)}"
	)

	acc
	end
	else
	Logger.debug(
	"#{policy} is excluded from config descriptions, because does not implement `config_description/0` method."
	)

	acc
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/drop_policy.ex b/lib/pleroma/web/activity_pub/mrf/drop_policy.ex
	index e4fcc9935..cf07db7f3 100644
	--- a/lib/pleroma/web/activity_pub/mrf/drop_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/drop_policy.ex
	@@ -1,18 +1,24 @@
	# 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.MRF.DropPolicy do
	require Logger
	@moduledoc "Drop and log everything received"
	@behaviour Pleroma.Web.ActivityPub.MRF.Policy

	@impl true
	def filter(activity) do
	Logger.debug("REJECTING #{inspect(activity)}")
	{:reject, activity}
	end

	+ @impl true
	+ def id_filter(id) do
	+ Logger.debug("REJECTING #{id}")
	+ false
	+ end
	+
	@impl true
	def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/policy.ex b/lib/pleroma/web/activity_pub/mrf/policy.ex
	index 54ca4b735..08bcac08a 100644
	--- a/lib/pleroma/web/activity_pub/mrf/policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/policy.ex
	@@ -1,17 +1,18 @@
	# 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.MRF.Policy do
	@callback filter(Pleroma.Activity.t()) :: {:ok \| :reject, Pleroma.Activity.t()}
	+ @callback id_filter(String.t()) :: boolean()
	@callback describe() :: {:ok \| :error, map()}
	@callback config_description() :: %{
	optional(:children) => [map()],
	key: atom(),
	related_policy: String.t(),
	label: String.t(),
	description: String.t()
	}
	@callback history_awareness() :: :auto \| :manual
	- @optional_callbacks config_description: 0, history_awareness: 0
	+ @optional_callbacks config_description: 0, history_awareness: 0, id_filter: 1
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/remote_report_policy.ex b/lib/pleroma/web/activity_pub/mrf/remote_report_policy.ex
	new file mode 100644
	index 000000000..fa0610bf1
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/mrf/remote_report_policy.ex
	@@ -0,0 +1,118 @@
	+defmodule Pleroma.Web.ActivityPub.MRF.RemoteReportPolicy do
	+ @moduledoc "Drop remote reports if they don't contain enough information."
	+ @behaviour Pleroma.Web.ActivityPub.MRF.Policy
	+
	+ alias Pleroma.Config
	+
	+ @impl true
	+ def filter(%{"type" => "Flag"} = object) do
	+ with {_, false} <- {:local, local?(object)},
	+ {:ok, _} <- maybe_reject_all(object),
	+ {:ok, _} <- maybe_reject_anonymous(object),
	+ {:ok, _} <- maybe_reject_third_party(object),
	+ {:ok, _} <- maybe_reject_empty_message(object) do
	+ {:ok, object}
	+ else
	+ {:local, true} -> {:ok, object}
	+ {:reject, message} -> {:reject, message}
	+ error -> {:reject, error}
	+ end
	+ end
	+
	+ def filter(object), do: {:ok, object}
	+
	+ defp maybe_reject_all(object) do
	+ if Config.get([:mrf_remote_report, :reject_all]) do
	+ {:reject, "[RemoteReportPolicy] Remote report"}
	+ else
	+ {:ok, object}
	+ end
	+ end
	+
	+ defp maybe_reject_anonymous(%{"actor" => actor} = object) do
	+ with true <- Config.get([:mrf_remote_report, :reject_anonymous]),
	+ %URI{path: "/actor"} <- URI.parse(actor) do
	+ {:reject, "[RemoteReportPolicy] Anonymous: #{actor}"}
	+ else
	+ _ -> {:ok, object}
	+ end
	+ end
	+
	+ defp maybe_reject_third_party(%{"object" => objects} = object) do
	+ {_, to} =
	+ case objects do
	+ [head \| tail] when is_binary(head) -> {tail, head}
	+ s when is_binary(s) -> {[], s}
	+ _ -> {[], ""}
	+ end
	+
	+ with true <- Config.get([:mrf_remote_report, :reject_third_party]),
	+ false <- String.starts_with?(to, Pleroma.Web.Endpoint.url()) do
	+ {:reject, "[RemoteReportPolicy] Third-party: #{to}"}
	+ else
	+ _ -> {:ok, object}
	+ end
	+ end
	+
	+ defp maybe_reject_empty_message(%{"content" => content} = object)
	+ when is_binary(content) and content != "" do
	+ {:ok, object}
	+ end
	+
	+ defp maybe_reject_empty_message(object) do
	+ if Config.get([:mrf_remote_report, :reject_empty_message]) do
	+ {:reject, ["RemoteReportPolicy] No content"]}
	+ else
	+ {:ok, object}
	+ end
	+ end
	+
	+ defp local?(%{"actor" => actor}) do
	+ String.starts_with?(actor, Pleroma.Web.Endpoint.url())
	+ end
	+
	+ @impl true
	+ def describe do
	+ mrf_remote_report =
	+ Config.get(:mrf_remote_report)
	+ \|> Enum.into(%{})
	+
	+ {:ok, %{mrf_remote_report: mrf_remote_report}}
	+ end
	+
	+ @impl true
	+ def config_description do
	+ %{
	+ key: :mrf_remote_report,
	+ related_policy: "Pleroma.Web.ActivityPub.MRF.RemoteReportPolicy",
	+ label: "MRF Remote Report",
	+ description: "Drop remote reports if they don't contain enough information.",
	+ children: [
	+ %{
	+ key: :reject_all,
	+ type: :boolean,
	+ description: "Reject all remote reports? (this option takes precedence)",
	+ suggestions: [false]
	+ },
	+ %{
	+ key: :reject_anonymous,
	+ type: :boolean,
	+ description: "Reject anonymous remote reports?",
	+ suggestions: [true]
	+ },
	+ %{
	+ key: :reject_third_party,
	+ type: :boolean,
	+ description: "Reject reports on users from third-party instances?",
	+ suggestions: [true]
	+ },
	+ %{
	+ key: :reject_empty_message,
	+ type: :boolean,
	+ description: "Reject remote reports with no message?",
	+ suggestions: [true]
	+ }
	+ ]
	+ }
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/mrf/simple_policy.ex b/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	index ae7f18bfe..a97e8db7b 100644
	--- a/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	@@ -1,364 +1,376 @@
	# 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.MRF.SimplePolicy do
	@moduledoc "Filter activities depending on their origin instance"
	@behaviour Pleroma.Web.ActivityPub.MRF.Policy

	alias Pleroma.Config
	alias Pleroma.FollowingRelationship
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF

	require Pleroma.Constants

	defp check_accept(%{host: actor_host} = _actor_info, activity) do
	accepts =
	instance_list(:accept)
	\|> MRF.subdomains_regex()

	cond do
	accepts == [] -> {:ok, activity}
	actor_host == Config.get([Pleroma.Web.Endpoint, :url, :host]) -> {:ok, activity}
	MRF.subdomain_match?(accepts, actor_host) -> {:ok, activity}
	true -> {:reject, "[SimplePolicy] host not in accept list"}
	end
	end

	defp check_reject(%{host: actor_host} = _actor_info, activity) do
	rejects =
	instance_list(:reject)
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(rejects, actor_host) do
	{:reject, "[SimplePolicy] host in reject list"}
	else
	{:ok, activity}
	end
	end

	defp check_media_removal(
	%{host: actor_host} = _actor_info,
	%{"type" => type, "object" => %{"attachment" => object_attachment}} = activity
	)
	when length(object_attachment) > 0 and type in ["Create", "Update"] do
	media_removal =
	instance_list(:media_removal)
	\|> MRF.subdomains_regex()

	activity =
	if MRF.subdomain_match?(media_removal, actor_host) do
	object = Map.delete(activity["object"], "attachment")
	Map.put(activity, "object", object)
	else
	activity
	end

	{:ok, activity}
	end

	defp check_media_removal(_actor_info, activity), do: {:ok, activity}

	defp check_media_nsfw(
	%{host: actor_host} = _actor_info,
	%{
	"type" => type,
	"object" => %{} = _object
	} = activity
	)
	when type in ["Create", "Update"] do
	media_nsfw =
	instance_list(:media_nsfw)
	\|> MRF.subdomains_regex()

	activity =
	if MRF.subdomain_match?(media_nsfw, actor_host) do
	Kernel.put_in(activity, ["object", "sensitive"], true)
	else
	activity
	end

	{:ok, activity}
	end

	defp check_media_nsfw(_actor_info, activity), do: {:ok, activity}

	defp check_ftl_removal(%{host: actor_host} = _actor_info, activity) do
	timeline_removal =
	instance_list(:federated_timeline_removal)
	\|> MRF.subdomains_regex()

	activity =
	with true <- MRF.subdomain_match?(timeline_removal, actor_host),
	user <- User.get_cached_by_ap_id(activity["actor"]),
	true <- Pleroma.Constants.as_public() in activity["to"] do
	to = List.delete(activity["to"], Pleroma.Constants.as_public()) ++ [user.follower_address]

	cc = List.delete(activity["cc"], user.follower_address) ++ [Pleroma.Constants.as_public()]

	activity
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)
	else
	_ -> activity
	end

	{:ok, activity}
	end

	defp intersection(list1, list2) do
	list1 -- list1 -- list2
	end

	defp check_followers_only(%{host: actor_host} = _actor_info, activity) do
	followers_only =
	instance_list(:followers_only)
	\|> MRF.subdomains_regex()

	activity =
	with true <- MRF.subdomain_match?(followers_only, actor_host),
	user <- User.get_cached_by_ap_id(activity["actor"]) do
	# Don't use Map.get/3 intentionally, these must not be nil
	fixed_to = activity["to"] \|\| []
	fixed_cc = activity["cc"] \|\| []

	to = FollowingRelationship.followers_ap_ids(user, fixed_to)
	cc = FollowingRelationship.followers_ap_ids(user, fixed_cc)

	activity
	\|> Map.put("to", intersection([user.follower_address \| to], fixed_to))
	\|> Map.put("cc", intersection([user.follower_address \| cc], fixed_cc))
	else
	_ -> activity
	end

	{:ok, activity}
	end

	defp check_report_removal(%{host: actor_host} = _actor_info, %{"type" => "Flag"} = activity) do
	report_removal =
	instance_list(:report_removal)
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(report_removal, actor_host) do
	{:reject, "[SimplePolicy] host in report_removal list"}
	else
	{:ok, activity}
	end
	end

	defp check_report_removal(_actor_info, activity), do: {:ok, activity}

	defp check_avatar_removal(%{host: actor_host} = _actor_info, %{"icon" => _icon} = activity) do
	avatar_removal =
	instance_list(:avatar_removal)
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(avatar_removal, actor_host) do
	{:ok, Map.delete(activity, "icon")}
	else
	{:ok, activity}
	end
	end

	defp check_avatar_removal(_actor_info, activity), do: {:ok, activity}

	defp check_banner_removal(%{host: actor_host} = _actor_info, %{"image" => _image} = activity) do
	banner_removal =
	instance_list(:banner_removal)
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(banner_removal, actor_host) do
	{:ok, Map.delete(activity, "image")}
	else
	{:ok, activity}
	end
	end

	defp check_banner_removal(_actor_info, activity), do: {:ok, activity}

	defp check_object(%{"object" => object} = activity) do
	with {:ok, _object} <- filter(object) do
	{:ok, activity}
	end
	end

	defp check_object(activity), do: {:ok, activity}

	defp instance_list(config_key) do
	Config.get([:mrf_simple, config_key])
	\|> MRF.instance_list_from_tuples()
	end

	+ @impl true
	+ def id_filter(id) do
	+ host_info = URI.parse(id)
	+
	+ with {:ok, _} <- check_accept(host_info, %{}),
	+ {:ok, _} <- check_reject(host_info, %{}) do
	+ true
	+ else
	+ _ -> false
	+ end
	+ end
	+
	@impl true
	def filter(%{"type" => "Delete", "actor" => actor} = activity) do
	%{host: actor_host} = URI.parse(actor)

	reject_deletes =
	instance_list(:reject_deletes)
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(reject_deletes, actor_host) do
	{:reject, "[SimplePolicy] host in reject_deletes list"}
	else
	{:ok, activity}
	end
	end

	@impl true
	def filter(%{"actor" => actor} = activity) do
	actor_info = URI.parse(actor)

	with {:ok, activity} <- check_accept(actor_info, activity),
	{:ok, activity} <- check_reject(actor_info, activity),
	{:ok, activity} <- check_media_removal(actor_info, activity),
	{:ok, activity} <- check_media_nsfw(actor_info, activity),
	{:ok, activity} <- check_ftl_removal(actor_info, activity),
	{:ok, activity} <- check_followers_only(actor_info, activity),
	{:ok, activity} <- check_report_removal(actor_info, activity),
	{:ok, activity} <- check_object(activity) do
	{:ok, activity}
	else
	{:reject, _} = e -> e
	end
	end

	def filter(%{"id" => actor, "type" => actor_type} = activity)
	when actor_type in ["Application", "Group", "Organization", "Person", "Service"] do
	actor_info = URI.parse(actor)

	with {:ok, activity} <- check_accept(actor_info, activity),
	{:ok, activity} <- check_reject(actor_info, activity),
	{:ok, activity} <- check_avatar_removal(actor_info, activity),
	{:ok, activity} <- check_banner_removal(actor_info, activity) do
	{:ok, activity}
	else
	{:reject, _} = e -> e
	end
	end

	def filter(activity) when is_binary(activity) do
	uri = URI.parse(activity)

	with {:ok, activity} <- check_accept(uri, activity),
	{:ok, activity} <- check_reject(uri, activity) do
	{:ok, activity}
	else
	{:reject, _} = e -> e
	end
	end

	def filter(activity), do: {:ok, activity}

	@impl true
	def describe do
	exclusions = Config.get([:mrf, :transparency_exclusions]) \|> MRF.instance_list_from_tuples()

	mrf_simple_excluded =
	Config.get(:mrf_simple)
	\|> Enum.map(fn {rule, instances} ->
	{rule, Enum.reject(instances, fn {host, _} -> host in exclusions end)}
	end)

	mrf_simple =
	mrf_simple_excluded
	\|> Enum.map(fn {rule, instances} ->
	{rule, Enum.map(instances, fn {host, _} -> host end)}
	end)
	\|> Map.new()

	# 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.
	mrf_simple_info =
	mrf_simple_excluded
	\|> Enum.map(fn {rule, instances} ->
	{rule, Enum.reject(instances, fn {_, reason} -> reason == "" end)}
	end)
	\|> Enum.reject(fn {_, instances} -> instances == [] end)
	\|> Enum.map(fn {rule, instances} ->
	instances =
	instances
	\|> Enum.map(fn {host, reason} -> {host, %{"reason" => reason}} end)
	\|> Map.new()

	{rule, instances}
	end)
	\|> Map.new()

	{:ok, %{mrf_simple: mrf_simple, mrf_simple_info: mrf_simple_info}}
	end

	@impl true
	def config_description do
	%{
	key: :mrf_simple,
	related_policy: "Pleroma.Web.ActivityPub.MRF.SimplePolicy",
	label: "MRF Simple",
	description: "Simple ingress policies",
	children:
	[
	%{
	key: :media_removal,
	description:
	"List of instances to strip media attachments from and the reason for doing so"
	},
	%{
	key: :media_nsfw,
	label: "Media NSFW",
	description:
	"List of instances to tag all media as NSFW (sensitive) from and the reason for doing so"
	},
	%{
	key: :federated_timeline_removal,
	description:
	"List of instances to remove from the Federated (aka The Whole Known Network) Timeline and the reason for doing so"
	},
	%{
	key: :reject,
	description:
	"List of instances to reject activities from (except deletes) and the reason for doing so"
	},
	%{
	key: :accept,
	description:
	"List of instances to only accept activities from (except deletes) and the reason for doing so"
	},
	%{
	key: :followers_only,
	description:
	"Force posts from the given instances to be visible by followers only and the reason for doing so"
	},
	%{
	key: :report_removal,
	description: "List of instances to reject reports from and the reason for doing so"
	},
	%{
	key: :avatar_removal,
	description: "List of instances to strip avatars from and the reason for doing so"
	},
	%{
	key: :banner_removal,
	description: "List of instances to strip banners from and the reason for doing so"
	},
	%{
	key: :reject_deletes,
	description: "List of instances to reject deletions from and the reason for doing so"
	}
	]
	\|> Enum.map(fn setting ->
	Map.merge(
	setting,
	%{
	type: {:list, :tuple},
	key_placeholder: "instance",
	value_placeholder: "reason",
	suggestions: [{"example.com", "Some reason"}, {"*.example.com", "Another reason"}]
	}
	)
	end)
	}
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index b3043b93a..35774d410 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,335 +1,347 @@
	# 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.ObjectValidator do
	@moduledoc """
	This module is responsible for validating an object (which can be an activity)
	and checking if it is both well formed and also compatible with our view of
	the system.
	"""

	@behaviour Pleroma.Web.ActivityPub.ObjectValidator.Validating

	+ import Pleroma.Constants, only: [activity_types: 0, object_types: 0]
	+
	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AcceptRejectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AddRemoveValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnswerValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AudioImageVideoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateGenericValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EventValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator

	@impl true
	def validate(object, meta)

	+ # This overload works together with the InboxGuardPlug
	+ # and ensures that we are not accepting any activity type
	+ # that cannot pass InboxGuardPlug.
	+ # If we want to support any more activity types, make sure to
	+ # add it in Pleroma.Constants's activity_types or object_types,
	+ # and, if applicable, allowed_activity_types_from_strangers.
	+ def validate(%{"type" => type}, _meta)
	+ when type not in activity_types() and type not in object_types(),
	+ do: {:error, :not_allowed_object_type}
	+
	def validate(%{"type" => "Block"} = block_activity, meta) do
	with {:ok, block_activity} <-
	block_activity
	\|> BlockValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	block_activity = stringify_keys(block_activity)
	outgoing_blocks = Pleroma.Config.get([:activitypub, :outgoing_blocks])

	meta =
	if !outgoing_blocks do
	Keyword.put(meta, :do_not_federate, true)
	else
	meta
	end

	{:ok, block_activity, meta}
	end
	end

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

	meta =
	meta
	\|> Keyword.put(:object_data, undone_object.data)

	{:ok, object, meta}
	end
	end

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

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

	def validate(
	%{"type" => "Create", "object" => %{"type" => objtype} = object} = create_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Image Event Article Note Page] do
	with {:ok, object_data} <- cast_and_apply_and_stringify_with_history(object),
	meta = Keyword.put(meta, :object_data, object_data),
	{:ok, create_activity} <-
	create_activity
	\|> CreateGenericValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Event Question Audio Video Image Article Note Page] do
	validator =
	case type do
	"Event" -> EventValidator
	"Question" -> QuestionValidator
	"Audio" -> AudioImageVideoValidator
	"Video" -> AudioImageVideoValidator
	"Image" -> AudioImageVideoValidator
	"Article" -> ArticleNotePageValidator
	"Note" -> ArticleNotePageValidator
	"Page" -> ArticleNotePageValidator
	end

	with {:ok, object} <-
	do_separate_with_history(object, fn object ->
	with {:ok, object} <-
	object
	\|> validator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)

	# Insert copy of hashtags as strings for the non-hashtag table indexing
	tag = (object["tag"] \|\| []) ++ Object.hashtags(%Object{data: object})
	object = Map.put(object, "tag", tag)

	{:ok, object}
	end
	end) do
	{:ok, object, meta}
	end
	end

	def validate(
	%{"type" => "Update", "object" => %{"type" => objtype} = object} = update_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Event Article Note Page] do
	with {_, false} <- {:local, Access.get(meta, :local, false)},
	{_, {:ok, object_data, _}} <- {:object_validation, validate(object, meta)},
	meta = Keyword.put(meta, :object_data, object_data),
	{:ok, update_activity} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	update_activity = stringify_keys(update_activity)
	{:ok, update_activity, meta}
	else
	{:local, _} ->
	with {:ok, object} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end

	{:object_validation, e} ->
	e

	{:error, %Ecto.Changeset{} = e} ->
	{:error, e}
	end
	end

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Accept Reject Follow Update Like EmojiReact Announce
	ChatMessage Answer] do
	validator =
	case type do
	"Accept" -> AcceptRejectValidator
	"Reject" -> AcceptRejectValidator
	"Follow" -> FollowValidator
	"Update" -> UpdateValidator
	"Like" -> LikeValidator
	"EmojiReact" -> EmojiReactValidator
	"Announce" -> AnnounceValidator
	"ChatMessage" -> ChatMessageValidator
	"Answer" -> AnswerValidator
	end

	with {:ok, object} <-
	object
	\|> validator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => type} = object, meta) when type in ~w(Add Remove) do
	with {:ok, object} <-
	object
	\|> AddRemoveValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(o, m), do: {:error, {:validator_not_set, {o, m}}}

	def cast_and_apply_and_stringify_with_history(object) do
	do_separate_with_history(object, fn object ->
	with {:ok, object_data} <- cast_and_apply(object),
	object_data <- object_data \|> stringify_keys() do
	{:ok, object_data}
	end
	end)
	end

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

	def cast_and_apply(%{"type" => "Question"} = object) do
	QuestionValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Answer"} = object) do
	AnswerValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => type} = object) when type in ~w[Audio Image Video] do
	AudioImageVideoValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => "Event"} = object) do
	EventValidator.cast_and_apply(object)
	end

	def cast_and_apply(%{"type" => type} = object) when type in ~w[Article Note Page] do
	ArticleNotePageValidator.cast_and_apply(object)
	end

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

	def stringify_keys(object) when is_struct(object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) when is_map(object) do
	object
	\|> Enum.filter(fn {_, v} -> v != nil end)
	\|> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
	end

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

	def stringify_keys(object), do: object

	def fetch_actor(object) do
	with actor <- Containment.get_actor(object),
	{:ok, actor} <- ObjectValidators.ObjectID.cast(actor) do
	User.get_or_fetch_by_ap_id(actor)
	end
	end

	def fetch_actor_and_object(object) do
	fetch_actor(object)
	Object.normalize(object["object"], fetch: true)
	:ok
	end

	defp for_each_history_item(
	%{"type" => "OrderedCollection", "orderedItems" => items} = history,
	object,
	fun
	) do
	processed_items =
	Enum.map(items, fn item ->
	with item <- Map.put(item, "id", object["id"]),
	{:ok, item} <- fun.(item) do
	item
	else
	_ -> nil
	end
	end)

	if Enum.all?(processed_items, &(not is_nil(&1))) do
	{:ok, Map.put(history, "orderedItems", processed_items)}
	else
	{:error, :invalid_history}
	end
	end

	defp for_each_history_item(nil, _object, _fun) do
	{:ok, nil}
	end

	defp for_each_history_item(_, _object, _fun) do
	{:error, :invalid_history}
	end

	# fun is (object -> {:ok, validated_object_with_string_keys})
	defp do_separate_with_history(object, fun) do
	with history <- object["formerRepresentations"],
	object <- Map.drop(object, ["formerRepresentations"]),
	{_, {:ok, object}} <- {:main_body, fun.(object)},
	{_, {:ok, history}} <- {:history_items, for_each_history_item(history, object, fun)} do
	object =
	if history do
	Map.put(object, "formerRepresentations", history)
	else
	object
	end

	{:ok, object}
	else
	{:main_body, e} -> e
	{:history_items, e} -> e
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/views/user_view.ex b/lib/pleroma/web/activity_pub/views/user_view.ex
	index 937e4fd67..cd485ed64 100644
	--- a/lib/pleroma/web/activity_pub/views/user_view.ex
	+++ b/lib/pleroma/web/activity_pub/views/user_view.ex
	@@ -1,320 +1,342 @@
	# 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.UserView do
	use Pleroma.Web, :view

	alias Pleroma.Keys
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query

	def render("endpoints.json", %{user: %User{nickname: nil, local: true} = _user}) do
	%{"sharedInbox" => Helpers.activity_pub_url(Endpoint, :inbox)}
	end

	def render("endpoints.json", %{user: %User{local: true} = _user}) do
	%{
	"oauthAuthorizationEndpoint" => Helpers.o_auth_url(Endpoint, :authorize),
	"oauthRegistrationEndpoint" => Helpers.app_url(Endpoint, :create),
	"oauthTokenEndpoint" => Helpers.o_auth_url(Endpoint, :token_exchange),
	"sharedInbox" => Helpers.activity_pub_url(Endpoint, :inbox),
	"uploadMedia" => Helpers.activity_pub_url(Endpoint, :upload_media)
	}
	end

	def render("endpoints.json", _), do: %{}

	def render("service.json", %{user: user}) do
	{:ok, _, public_key} = Keys.keys_from_pem(user.keys)
	public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
	public_key = :public_key.pem_encode([public_key])

	endpoints = render("endpoints.json", %{user: user})

	%{
	"id" => user.ap_id,
	"type" => "Application",
	"following" => "#{user.ap_id}/following",
	"followers" => "#{user.ap_id}/followers",
	"inbox" => "#{user.ap_id}/inbox",
	"outbox" => "#{user.ap_id}/outbox",
	"name" => "Pleroma",
	"summary" =>
	"An internal service actor for this Pleroma instance. No user-serviceable parts inside.",
	"url" => user.ap_id,
	"manuallyApprovesFollowers" => false,
	"publicKey" => %{
	"id" => "#{user.ap_id}#main-key",
	"owner" => user.ap_id,
	"publicKeyPem" => public_key
	},
	"endpoints" => endpoints,
	"invisible" => User.invisible?(user)
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	# the instance itself is not a Person, but instead an Application
	def render("user.json", %{user: %User{nickname: nil} = user}),
	do: render("service.json", %{user: user})

	def render("user.json", %{user: %User{nickname: "internal." <> _} = user}) do
	render("service.json", %{user: user})
	\|> Map.merge(%{
	"preferredUsername" => user.nickname,
	"webfinger" => "acct:#{User.full_nickname(user)}"
	})
	end

	def render("user.json", %{user: user}) do
	{:ok, _, public_key} = Keys.keys_from_pem(user.keys)
	public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
	public_key = :public_key.pem_encode([public_key])
	user = User.sanitize_html(user)

	endpoints = render("endpoints.json", %{user: user})

	emoji_tags = Transmogrifier.take_emoji_tags(user)

	fields = Enum.map(user.fields, &Map.put(&1, "type", "PropertyValue"))

	capabilities =
	if is_boolean(user.accepts_chat_messages) do
	%{
	"acceptsChatMessages" => user.accepts_chat_messages
	}
	else
	%{}
	end

	birthday =
	if user.show_birthday && user.birthday,
	do: Date.to_iso8601(user.birthday),
	else: nil

	%{
	"id" => user.ap_id,
	"type" => user.actor_type,
	"following" => "#{user.ap_id}/following",
	"followers" => "#{user.ap_id}/followers",
	"inbox" => "#{user.ap_id}/inbox",
	"outbox" => "#{user.ap_id}/outbox",
	"featured" => "#{user.ap_id}/collections/featured",
	"preferredUsername" => user.nickname,
	"name" => user.name,
	"summary" => user.bio,
	"url" => user.ap_id,
	"manuallyApprovesFollowers" => user.is_locked,
	"publicKey" => %{
	"id" => "#{user.ap_id}#main-key",
	"owner" => user.ap_id,
	"publicKeyPem" => public_key
	},
	"endpoints" => endpoints,
	"attachment" => fields,
	"tag" => emoji_tags,
	# Note: key name is indeed "discoverable" (not an error)
	"discoverable" => user.is_discoverable,
	"capabilities" => capabilities,
	"alsoKnownAs" => user.also_known_as,
	"vcard:bday" => birthday,
	"webfinger" => "acct:#{User.full_nickname(user)}"
	}
	- \|> Map.merge(maybe_make_image(&User.avatar_url/2, "icon", user))
	- \|> Map.merge(maybe_make_image(&User.banner_url/2, "image", user))
	+ \|> Map.merge(
	+ maybe_make_image(
	+ &User.avatar_url/2,
	+ User.image_description(user.avatar, nil),
	+ "icon",
	+ user
	+ )
	+ )
	+ \|> Map.merge(
	+ maybe_make_image(
	+ &User.banner_url/2,
	+ User.image_description(user.banner, nil),
	+ "image",
	+ user
	+ )
	+ )
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("following.json", %{user: user, page: page} = opts) do
	showing_items = (opts[:for] && opts[:for] == user) \|\| !user.hide_follows
	showing_count = showing_items \|\| !user.hide_follows_count

	query = User.get_friends_query(user)
	query = from(user in query, select: [:ap_id])
	following = Repo.all(query)

	total =
	if showing_count do
	length(following)
	else
	0
	end

	collection(following, "#{user.ap_id}/following", page, showing_items, total)
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("following.json", %{user: user} = opts) do
	showing_items = (opts[:for] && opts[:for] == user) \|\| !user.hide_follows
	showing_count = showing_items \|\| !user.hide_follows_count

	query = User.get_friends_query(user)
	query = from(user in query, select: [:ap_id])
	following = Repo.all(query)

	total =
	if showing_count do
	length(following)
	else
	0
	end

	%{
	"id" => "#{user.ap_id}/following",
	"type" => "OrderedCollection",
	"totalItems" => total,
	"first" =>
	if showing_items do
	collection(following, "#{user.ap_id}/following", 1, !user.hide_follows)
	else
	"#{user.ap_id}/following?page=1"
	end
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("followers.json", %{user: user, page: page} = opts) do
	showing_items = (opts[:for] && opts[:for] == user) \|\| !user.hide_followers
	showing_count = showing_items \|\| !user.hide_followers_count

	query = User.get_followers_query(user)
	query = from(user in query, select: [:ap_id])
	followers = Repo.all(query)

	total =
	if showing_count do
	length(followers)
	else
	0
	end

	collection(followers, "#{user.ap_id}/followers", page, showing_items, total)
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("followers.json", %{user: user} = opts) do
	showing_items = (opts[:for] && opts[:for] == user) \|\| !user.hide_followers
	showing_count = showing_items \|\| !user.hide_followers_count

	query = User.get_followers_query(user)
	query = from(user in query, select: [:ap_id])
	followers = Repo.all(query)

	total =
	if showing_count do
	length(followers)
	else
	0
	end

	%{
	"id" => "#{user.ap_id}/followers",
	"type" => "OrderedCollection",
	"first" =>
	if showing_items do
	collection(followers, "#{user.ap_id}/followers", 1, showing_items, total)
	else
	"#{user.ap_id}/followers?page=1"
	end
	}
	\|> maybe_put_total_items(showing_count, total)
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("activity_collection.json", %{iri: iri}) do
	%{
	"id" => iri,
	"type" => "OrderedCollection",
	"first" => "#{iri}?page=true"
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("activity_collection_page.json", %{
	activities: activities,
	iri: iri,
	pagination: pagination
	}) do
	collection =
	Enum.map(activities, fn activity ->
	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
	data
	end)

	%{
	"type" => "OrderedCollectionPage",
	"partOf" => iri,
	"orderedItems" => collection
	}
	\|> Map.merge(Utils.make_json_ld_header())
	\|> Map.merge(pagination)
	end

	def render("featured.json", %{
	user: %{featured_address: featured_address, pinned_objects: pinned_objects}
	}) do
	objects =
	pinned_objects
	\|> Enum.sort_by(fn {_, pinned_at} -> pinned_at end, &>=/2)
	\|> Enum.map(fn {id, _} ->
	ObjectView.render("object.json", %{object: Object.get_cached_by_ap_id(id)})
	end)

	%{
	"id" => featured_address,
	"type" => "OrderedCollection",
	"orderedItems" => objects,
	"totalItems" => length(objects)
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	defp maybe_put_total_items(map, false, _total), do: map

	defp maybe_put_total_items(map, true, total) do
	Map.put(map, "totalItems", total)
	end

	def collection(collection, iri, page, show_items \\ true, total \\ nil) do
	offset = (page - 1) * 10
	items = Enum.slice(collection, offset, 10)
	items = Enum.map(items, fn user -> user.ap_id end)
	total = total \|\| length(collection)

	map = %{
	"id" => "#{iri}?page=#{page}",
	"type" => "OrderedCollectionPage",
	"partOf" => iri,
	"totalItems" => total,
	"orderedItems" => if(show_items, do: items, else: [])
	}

	if offset < total do
	Map.put(map, "next", "#{iri}?page=#{page + 1}")
	else
	map
	end
	end

	- defp maybe_make_image(func, key, user) do
	+ defp maybe_make_image(func, description, key, user) do
	if image = func.(user, no_default: true) do
	%{
	- key => %{
	- "type" => "Image",
	- "url" => image
	- }
	+ key =>
	+ %{
	+ "type" => "Image",
	+ "url" => image
	+ }
	+ \|> maybe_put_description(description)
	}
	else
	%{}
	end
	end
	+
	+ defp maybe_put_description(map, description) when is_binary(description) do
	+ Map.put(map, "name", description)
	+ end
	+
	+ defp maybe_put_description(map, _description), do: map
	end
	diff --git a/lib/pleroma/web/api_spec/operations/media_operation.ex b/lib/pleroma/web/api_spec/operations/media_operation.ex
	index e6df21246..588b42e06 100644
	--- a/lib/pleroma/web/api_spec/operations/media_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/media_operation.ex
	@@ -1,135 +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.MediaOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Helpers
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.Attachment

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

	def create_operation do
	%Operation{
	tags: ["Media attachments"],
	summary: "Upload media as attachment",
	description: "Creates an attachment to be used with a new status.",
	operationId: "MediaController.create",
	security: [%{"oAuth" => ["write:media"]}],
	requestBody: Helpers.request_body("Parameters", create_request()),
	responses: %{
	200 => Operation.response("Media", "application/json", Attachment),
	400 => Operation.response("Media", "application/json", ApiError),
	401 => Operation.response("Media", "application/json", ApiError),
	422 => Operation.response("Media", "application/json", ApiError)
	}
	}
	end

	defp create_request do
	%Schema{
	title: "MediaCreateRequest",
	description: "POST body for creating an attachment",
	type: :object,
	required: [:file],
	properties: %{
	file: %Schema{
	type: :string,
	format: :binary,
	description: "The file to be attached, using multipart form data."
	},
	description: %Schema{
	type: :string,
	description: "A plain-text description of the media, for accessibility purposes."
	},
	focus: %Schema{
	type: :string,
	description: "Two floating points (x,y), comma-delimited, ranging from -1.0 to 1.0."
	}
	}
	}
	end

	def update_operation do
	%Operation{
	tags: ["Media attachments"],
	summary: "Update attachment",
	description: "Creates an attachment to be used with a new status.",
	operationId: "MediaController.update",
	security: [%{"oAuth" => ["write:media"]}],
	parameters: [id_param()],
	requestBody: Helpers.request_body("Parameters", update_request()),
	responses: %{
	200 => Operation.response("Media", "application/json", Attachment),
	400 => Operation.response("Media", "application/json", ApiError),
	401 => Operation.response("Media", "application/json", ApiError),
	422 => Operation.response("Media", "application/json", ApiError)
	}
	}
	end

	defp update_request do
	%Schema{
	title: "MediaUpdateRequest",
	description: "POST body for updating an attachment",
	type: :object,
	properties: %{
	file: %Schema{
	type: :string,
	format: :binary,
	description: "The file to be attached, using multipart form data."
	},
	description: %Schema{
	type: :string,
	description: "A plain-text description of the media, for accessibility purposes."
	},
	focus: %Schema{
	type: :string,
	description: "Two floating points (x,y), comma-delimited, ranging from -1.0 to 1.0."
	}
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Media attachments"],
	summary: "Attachment",
	operationId: "MediaController.show",
	parameters: [id_param()],
	security: [%{"oAuth" => ["read:media"]}],
	responses: %{
	200 => Operation.response("Media", "application/json", Attachment),
	401 => Operation.response("Media", "application/json", ApiError),
	403 => Operation.response("Media", "application/json", ApiError),
	422 => Operation.response("Media", "application/json", ApiError)
	}
	}
	end

	def create2_operation do
	%Operation{
	tags: ["Media attachments"],
	summary: "Upload media as attachment (v2)",
	description: "Creates an attachment to be used with a new status.",
	operationId: "MediaController.create2",
	security: [%{"oAuth" => ["write:media"]}],
	requestBody: Helpers.request_body("Parameters", create_request()),
	responses: %{
	- 202 => Operation.response("Media", "application/json", Attachment),
	+ 200 => Operation.response("Media", "application/json", Attachment),
	400 => Operation.response("Media", "application/json", ApiError),
	422 => Operation.response("Media", "application/json", ApiError),
	500 => Operation.response("Media", "application/json", ApiError)
	}
	}
	end

	defp id_param do
	Operation.parameter(:id, :path, :string, "The ID of the Attachment entity")
	end
	end
	diff --git a/lib/pleroma/web/auth/authenticator.ex b/lib/pleroma/web/auth/authenticator.ex
	index 01bf1575c..95be892cd 100644
	--- a/lib/pleroma/web/auth/authenticator.ex
	+++ b/lib/pleroma/web/auth/authenticator.ex
	@@ -1,13 +1,18 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.Authenticator do
	@callback get_user(Plug.Conn.t()) :: {:ok, user :: struct()} \| {:error, any()}
	@callback create_from_registration(Plug.Conn.t(), registration :: struct()) ::
	{:ok, Pleroma.User.t()} \| {:error, any()}
	@callback get_registration(Plug.Conn.t()) :: {:ok, registration :: struct()} \| {:error, any()}
	@callback handle_error(Plug.Conn.t(), any()) :: any()
	@callback auth_template() :: String.t() \| nil
	@callback oauth_consumer_template() :: String.t() \| nil
	+
	+ @callback change_password(Pleroma.User.t(), String.t(), String.t(), String.t()) ::
	+ {:ok, Pleroma.User.t()} \| {:error, term()}
	+
	+ @optional_callbacks change_password: 4
	end
	diff --git a/lib/pleroma/web/auth/ldap_authenticator.ex b/lib/pleroma/web/auth/ldap_authenticator.ex
	index 7eb06183d..ec6601fb9 100644
	--- a/lib/pleroma/web/auth/ldap_authenticator.ex
	+++ b/lib/pleroma/web/auth/ldap_authenticator.ex
	@@ -1,33 +1,42 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.LDAPAuthenticator do
	alias Pleroma.LDAP
	alias Pleroma.User

	import Pleroma.Web.Auth.Helpers, only: [fetch_credentials: 1]

	@behaviour Pleroma.Web.Auth.Authenticator
	@base Pleroma.Web.Auth.PleromaAuthenticator

	defdelegate get_registration(conn), to: @base
	defdelegate create_from_registration(conn, registration), to: @base
	defdelegate handle_error(conn, error), to: @base
	defdelegate auth_template, to: @base
	defdelegate oauth_consumer_template, to: @base

	def get_user(%Plug.Conn{} = conn) do
	with {:ldap, true} <- {:ldap, Pleroma.Config.get([:ldap, :enabled])},
	{:ok, {name, password}} <- fetch_credentials(conn),
	%User{} = user <- LDAP.bind_user(name, password) do
	{:ok, user}
	else
	{:ldap, _} ->
	@base.get_user(conn)

	error ->
	error
	end
	end
	+
	+ def change_password(user, password, new_password, new_password) do
	+ case LDAP.change_password(user.nickname, password, new_password) do
	+ :ok -> {:ok, user}
	+ e -> e
	+ end
	+ end
	+
	+ def change_password(_, _, _, _), do: {:error, :password_confirmation}
	end
	diff --git a/lib/pleroma/web/auth/pleroma_authenticator.ex b/lib/pleroma/web/auth/pleroma_authenticator.ex
	index 09a58eb66..0da3f19fc 100644
	--- a/lib/pleroma/web/auth/pleroma_authenticator.ex
	+++ b/lib/pleroma/web/auth/pleroma_authenticator.ex
	@@ -1,104 +1,124 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.PleromaAuthenticator do
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	+ alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.AuthenticationPlug

	import Pleroma.Web.Auth.Helpers, only: [fetch_credentials: 1, fetch_user: 1]

	@behaviour Pleroma.Web.Auth.Authenticator

	def get_user(%Plug.Conn{} = conn) do
	with {:ok, {name, password}} <- fetch_credentials(conn),
	{_, %User{} = user} <- {:user, fetch_user(name)},
	{_, true} <- {:checkpw, AuthenticationPlug.checkpw(password, user.password_hash)},
	{:ok, user} <- AuthenticationPlug.maybe_update_password(user, password) do
	{:ok, user}
	else
	{:error, _reason} = error -> error
	error -> {:error, error}
	end
	end

	@doc """
	Gets or creates Pleroma.Registration record from Ueberauth assigns.
	Note: some strategies (like `keycloak`) might need extra configuration to fill `uid` from callback response —
	see [`docs/config.md`](docs/config.md).
	"""
	def get_registration(%Plug.Conn{assigns: %{ueberauth_auth: %{uid: nil}}}),
	do: {:error, :missing_uid}

	def get_registration(%Plug.Conn{
	assigns: %{ueberauth_auth: %{provider: provider, uid: uid} = auth}
	}) do
	registration = Registration.get_by_provider_uid(provider, uid)

	if registration do
	{:ok, registration}
	else
	info = auth.info

	%Registration{}
	\|> Registration.changeset(%{
	provider: to_string(provider),
	uid: to_string(uid),
	info: %{
	"nickname" => info.nickname,
	"email" => info.email,
	"name" => info.name,
	"description" => info.description
	}
	})
	\|> Repo.insert()
	end
	end

	def get_registration(%Plug.Conn{} = _conn), do: {:error, :missing_credentials}

	@doc "Creates Pleroma.User record basing on params and Pleroma.Registration record."
	def create_from_registration(
	%Plug.Conn{params: %{"authorization" => registration_attrs}},
	%Registration{} = registration
	) do
	nickname = value([registration_attrs["nickname"], Registration.nickname(registration)])
	email = value([registration_attrs["email"], Registration.email(registration)])
	name = value([registration_attrs["name"], Registration.name(registration)]) \|\| nickname
	bio = value([registration_attrs["bio"], Registration.description(registration)]) \|\| ""

	random_password = :crypto.strong_rand_bytes(64) \|> Base.encode64()

	with {:ok, new_user} <-
	User.register_changeset(
	%User{},
	%{
	email: email,
	nickname: nickname,
	name: name,
	bio: bio,
	password: random_password,
	password_confirmation: random_password
	},
	external: true,
	confirmed: true
	)
	\|> Repo.insert(),
	{:ok, _} <-
	Registration.changeset(registration, %{user_id: new_user.id}) \|> Repo.update() do
	{:ok, new_user}
	end
	end

	defp value(list), do: Enum.find(list, &(to_string(&1) != ""))

	def handle_error(%Plug.Conn{} = _conn, error) do
	error
	end

	def auth_template, do: nil

	def oauth_consumer_template, do: nil
	+
	+ @doc "Changes Pleroma.User password in the database"
	+ def change_password(user, password, new_password, new_password) do
	+ case CommonAPI.Utils.confirm_current_password(user, password) do
	+ {:ok, user} ->
	+ with {:ok, _user} <-
	+ User.reset_password(user, %{
	+ password: new_password,
	+ password_confirmation: new_password
	+ }) do
	+ {:ok, user}
	+ end
	+
	+ error ->
	+ error
	+ end
	+ end
	+
	+ def change_password(_, _, _, _), do: {:error, :password_confirmation}
	end
	diff --git a/lib/pleroma/web/auth/wrapper_authenticator.ex b/lib/pleroma/web/auth/wrapper_authenticator.ex
	index a077cfa41..97b901036 100644
	--- a/lib/pleroma/web/auth/wrapper_authenticator.ex
	+++ b/lib/pleroma/web/auth/wrapper_authenticator.ex
	@@ -1,42 +1,46 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.WrapperAuthenticator do
	@behaviour Pleroma.Web.Auth.Authenticator

	defp implementation do
	Pleroma.Config.get(
	Pleroma.Web.Auth.Authenticator,
	Pleroma.Web.Auth.PleromaAuthenticator
	)
	end

	@impl true
	def get_user(plug), do: implementation().get_user(plug)

	@impl true
	def create_from_registration(plug, registration),
	do: implementation().create_from_registration(plug, registration)

	@impl true
	def get_registration(plug), do: implementation().get_registration(plug)

	@impl true
	def handle_error(plug, error),
	do: implementation().handle_error(plug, error)

	@impl true
	def auth_template do
	# Note: `config :pleroma, :auth_template, "..."` support is deprecated
	implementation().auth_template() \|\|
	Pleroma.Config.get([:auth, :auth_template], Pleroma.Config.get(:auth_template)) \|\|
	"show.html"
	end

	@impl true
	def oauth_consumer_template do
	implementation().oauth_consumer_template() \|\|
	Pleroma.Config.get([:auth, :oauth_consumer_template], "consumer.html")
	end
	+
	+ @impl true
	+ def change_password(user, password, new_password, new_password_confirmation),
	+ do: implementation().change_password(user, password, new_password, new_password_confirmation)
	end
	diff --git a/lib/pleroma/web/feed/tag_controller.ex b/lib/pleroma/web/feed/tag_controller.ex
	index e60767327..02d639296 100644
	--- a/lib/pleroma/web/feed/tag_controller.ex
	+++ b/lib/pleroma/web/feed/tag_controller.ex
	@@ -1,48 +1,50 @@
	# 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.TagController do
	use Pleroma.Web, :controller

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

	def feed(conn, params) do
	- if Config.get!([:instance, :public]) do
	+ if not Config.restrict_unauthenticated_access?(:timelines, :local) do
	render_feed(conn, params)
	else
	render_error(conn, :not_found, "Not found")
	end
	end

	defp render_feed(conn, %{"tag" => raw_tag} = params) do
	+ local_only = Config.restrict_unauthenticated_access?(:timelines, :federated)
	+
	{format, tag} = parse_tag(raw_tag)

	activities =
	- %{type: ["Create"], tag: tag}
	+ %{type: ["Create"], tag: tag, local_only: local_only}
	\|> Pleroma.Maps.put_if_present(:max_id, params["max_id"])
	\|> ActivityPub.fetch_public_activities()

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

	@spec parse_tag(binary() \| any()) :: {format :: String.t(), tag :: String.t()}
	defp parse_tag(raw_tag) do
	case is_binary(raw_tag) && Enum.reverse(String.split(raw_tag, ".")) do
	[format \| tag] when format in ["rss", "atom"] ->
	{format, Enum.join(tag, ".")}

	_ ->
	{"atom", raw_tag}
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/media_controller.ex b/lib/pleroma/web/mastodon_api/controllers/media_controller.ex
	index 056bad844..41056d389 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/media_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/media_controller.ex
	@@ -1,96 +1,94 @@
	# 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.MediaController do
	use Pleroma.Web, :controller

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
	plug(Majic.Plug, [pool: Pleroma.MajicPool] when action in [:create, :create2])
	plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)

	plug(OAuthScopesPlug, %{scopes: ["read:media"]} when action == :show)
	plug(OAuthScopesPlug, %{scopes: ["write:media"]} when action != :show)

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

	@doc "POST /api/v1/media"
	def create(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: %{file: file} = data}}} =
	conn,
	_
	) do
	with {:ok, object} <-
	ActivityPub.upload(
	file,
	actor: User.ap_id(user),
	description: Map.get(data, :description)
	) do
	attachment_data = Map.put(object.data, "id", object.id)

	render(conn, "attachment.json", %{attachment: attachment_data})
	end
	end

	def create(_conn, _data), do: {:error, :bad_request}

	@doc "POST /api/v2/media"
	def create2(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: %{file: file} = data}}} =
	conn,
	_
	) do
	with {:ok, object} <-
	ActivityPub.upload(
	file,
	actor: User.ap_id(user),
	description: Map.get(data, :description)
	) do
	attachment_data = Map.put(object.data, "id", object.id)

	- conn
	- \|> put_status(202)
	- \|> render("attachment.json", %{attachment: attachment_data})
	+ render(conn, "attachment.json", %{attachment: attachment_data})
	end
	end

	def create2(_conn, _data), do: {:error, :bad_request}

	@doc "PUT /api/v1/media/:id"
	def update(
	%{
	assigns: %{user: user},
	private: %{
	open_api_spex: %{body_params: %{description: description}, params: %{id: id}}
	}
	} = conn,
	_
	) do
	with %Object{} = object <- Object.get_by_id(id),
	:ok <- Object.authorize_access(object, user),
	{:ok, %Object{data: data}} <- Object.update_data(object, %{"name" => description}) do
	attachment_data = Map.put(data, "id", object.id)

	render(conn, "attachment.json", %{attachment: attachment_data})
	end
	end

	def update(conn, data), do: show(conn, data)

	@doc "GET /api/v1/media/:id"
	def show(%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	with %Object{data: data, id: object_id} = object <- Object.get_by_id(id),
	:ok <- Object.authorize_access(object, user) do
	attachment_data = Map.put(data, "id", object_id)

	render(conn, "attachment.json", %{attachment: attachment_data})
	end
	end

	def show(_conn, _data), do: {:error, :bad_request}
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/poll_controller.ex b/lib/pleroma/web/mastodon_api/controllers/poll_controller.ex
	index a2af8148c..6526457df 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/poll_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/poll_controller.ex
	@@ -1,73 +1,87 @@
	# 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.PollController do
	use Pleroma.Web, :controller

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

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	+ alias Pleroma.Workers.PollWorker

	action_fallback(Pleroma.Web.MastodonAPI.FallbackController)

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

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

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

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

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

	@doc "GET /api/v1/polls/:id"
	def show(%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	- with %Object{} = object <- Object.get_by_id_and_maybe_refetch(id, interval: 60),
	- %Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
	+ with %Object{} = object <- Object.get_by_id(id),
	+ %Activity{} = activity <-
	+ Activity.get_create_by_object_ap_id_with_object(object.data["id"]),
	true <- Visibility.visible_for_user?(activity, user) do
	+ maybe_refresh_poll(activity)
	+
	try_render(conn, "show.json", %{object: object, for: user})
	else
	error when is_nil(error) or error == false ->
	render_error(conn, :not_found, "Record not found")
	end
	end

	@doc "POST /api/v1/polls/:id/votes"
	def vote(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: %{choices: choices}, params: %{id: id}}}
	} = conn,
	_
	) do
	with %Object{data: %{"type" => "Question"}} = object <- Object.get_by_id(id),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, _activities, object} <- get_cached_vote_or_vote(object, user, choices) do
	try_render(conn, "show.json", %{object: object, for: user})
	else
	nil -> render_error(conn, :not_found, "Record not found")
	false -> render_error(conn, :not_found, "Record not found")
	{:error, message} -> json_response(conn, :unprocessable_entity, %{error: message})
	end
	end

	defp get_cached_vote_or_vote(object, user, choices) do
	idempotency_key = "polls:#{user.id}:#{object.data["id"]}"

	@cachex.fetch!(:idempotency_cache, idempotency_key, fn _ ->
	case CommonAPI.vote(object, user, choices) do
	{:error, _message} = res -> {:ignore, res}
	res -> {:commit, res}
	end
	end)
	end
	+
	+ defp maybe_refresh_poll(%Activity{object: %Object{} = object} = activity) do
	+ with false <- activity.local,
	+ {:ok, end_time} <- NaiveDateTime.from_iso8601(object.data["closed"]),
	+ {_, :lt} <- {:closed_compare, NaiveDateTime.compare(object.updated_at, end_time)} do
	+ PollWorker.new(%{"op" => "refresh", "activity_id" => activity.id})
	+ \|> Oban.insert(unique: [period: @poll_refresh_interval])
	+ end
	+ end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
	index 7de6745d4..f6727d29d 100644
	--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
	@@ -1,507 +1,503 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

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

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

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

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

	opts =
	opts
	\|> Map.merge(%{relationships: relationships_opt, as: :user})
	\|> Map.delete(:users)

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

	@doc """
	Renders specified user account.
	:skip_visibility_check option skips visibility check and renders any user (local or remote)
	regardless of [:pleroma, :restrict_unauthenticated] setting.
	:for option specifies the requester and can be a User record or nil.
	Only use `user: user, for: user` when `user` is the actual requester of own profile.
	"""
	def render("show.json", %{user: _user, skip_visibility_check: true} = opts) do
	do_render("show.json", opts)
	end

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

	def render("show.json", _) do
	raise "In order to prevent account accessibility issues, " <>
	":skip_visibility_check or :for option is required."
	end

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

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

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

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

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

	followed_by = FollowingRelationship.following?(target, reading_user)
	following = FollowingRelationship.following?(reading_user, target)

	requested =
	cond do
	following -> false
	true -> match?(:follow_pending, follow_state)
	end

	subscribing =
	UserRelationship.exists?(
	user_relationships,
	:inverse_subscription,
	target,
	reading_user,
	&User.subscribed_to?(&2, &1)
	)

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

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

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

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

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

	def render("familiar_followers.json", %{users: users} = opts) do
	opts =
	opts
	\|> Map.merge(%{as: :user})
	\|> Map.delete(:users)

	users
	\|> render_many(AccountView, "familiar_followers.json", opts)
	end

	def render("familiar_followers.json", %{user: %{id: id, accounts: accounts}} = opts) do
	accounts =
	accounts
	\|> render_many(AccountView, "show.json", opts)
	\|> Enum.filter(&Enum.any?/1)

	%{id: id, accounts: accounts}
	end

	defp do_render("show.json", %{user: user} = opts) do
	self = opts[:for] == user

	user = User.sanitize_html(user, User.html_filter_policy(opts[:for]))
	display_name = user.name \|\| user.nickname

	avatar = User.avatar_url(user) \|> MediaProxy.url()
	avatar_static = User.avatar_url(user) \|> MediaProxy.preview_url(static: true)
	- avatar_description = image_description(user.avatar)
	+ avatar_description = User.image_description(user.avatar)
	header = User.banner_url(user) \|> MediaProxy.url()
	header_static = User.banner_url(user) \|> MediaProxy.preview_url(static: true)
	- header_description = image_description(user.banner)
	+ header_description = User.image_description(user.banner)

	following_count =
	if !user.hide_follows_count or !user.hide_follows or self,
	do: user.following_count,
	else: 0

	followers_count =
	if !user.hide_followers_count or !user.hide_followers or self,
	do: user.follower_count,
	else: 0

	bot = bot?(user)

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

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

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

	favicon =
	if Pleroma.Config.get([:instances_favicons, :enabled]) do
	user
	\|> Map.get(:ap_id, "")
	\|> URI.parse()
	\|> URI.merge("/")
	\|> Pleroma.Instances.Instance.get_or_update_favicon()
	\|> MediaProxy.url()
	else
	nil
	end

	last_status_at =
	user.last_status_at &&
	user.last_status_at \|> NaiveDateTime.to_date() \|> Date.to_iso8601()

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

	# Pleroma extensions
	# Note: it's insecure to output :email but fully-qualified nickname may serve as safe stub
	fqn: User.full_nickname(user),
	pleroma: %{
	ap_id: user.ap_id,
	also_known_as: user.also_known_as,
	is_confirmed: user.is_confirmed,
	is_suggested: user.is_suggested,
	tags: user.tags,
	hide_followers_count: user.hide_followers_count,
	hide_follows_count: user.hide_follows_count,
	hide_followers: user.hide_followers,
	hide_follows: user.hide_follows,
	hide_favorites: user.hide_favorites,
	relationship: relationship,
	skip_thread_containment: user.skip_thread_containment,
	background_image: image_url(user.background) \|> MediaProxy.url(),
	accepts_chat_messages: user.accepts_chat_messages,
	favicon: favicon,
	avatar_description: avatar_description,
	header_description: header_description
	}
	}
	\|> maybe_put_role(user, opts[:for])
	\|> maybe_put_settings(user, opts[:for], opts)
	\|> maybe_put_notification_settings(user, opts[:for])
	\|> maybe_put_settings_store(user, opts[:for], opts)
	\|> maybe_put_chat_token(user, opts[:for], opts)
	\|> maybe_put_activation_status(user, opts[:for])
	\|> maybe_put_follow_requests_count(user, opts[:for])
	\|> maybe_put_allow_following_move(user, opts[:for])
	\|> maybe_put_unread_conversation_count(user, opts[:for])
	\|> maybe_put_unread_notification_count(user, opts[:for])
	\|> maybe_put_email_address(user, opts[:for])
	\|> maybe_put_mute_expires_at(user, opts[:for], opts)
	\|> maybe_show_birthday(user, opts[:for])
	end

	defp username_from_nickname(string) when is_binary(string) do
	hd(String.split(string, "@"))
	end

	defp username_from_nickname(_), do: nil

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

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

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

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

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

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

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

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

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

	defp maybe_put_role(data, %User{show_role: true} = user, _) do
	put_role(data, user)
	end

	defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
	put_role(data, user)
	end

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

	defp put_role(data, user) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.is_moderator)
	\|> Kernel.put_in([:pleroma, :privileges], User.privileges(user))
	end

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

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

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

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

	defp maybe_put_activation_status(data, user, user_for) do
	if User.privileged?(user_for, :users_manage_activation_state),
	do: Kernel.put_in(data, [:pleroma, :deactivated], !user.is_active),
	else: data
	end

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

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

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

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

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

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

	defp maybe_put_mute_expires_at(data, %User{} = user, target, %{mutes: true}) do
	Map.put(
	data,
	:mute_expires_at,
	UserRelationship.get_mute_expire_date(target, user)
	)
	end

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

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

	defp maybe_show_birthday(data, %User{show_birthday: true} = user, _) do
	data
	\|> Kernel.put_in([:pleroma, :birthday], user.birthday)
	end

	defp maybe_show_birthday(data, _, _) do
	data
	end

	defp image_url(%{"url" => [%{"href" => href} \| _]}), do: href
	defp image_url(_), do: nil

	defp bot?(user) do
	# Because older and/or Mastodon clients may not recognize a Group actor properly,
	# and currently the group actor can only boost things, we should let these clients
	# think groups are bots.
	# See https://git.pleroma.social/pleroma/pleroma-meta/-/issues/14
	user.actor_type == "Service" \|\| user.actor_type == "Group"
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index 6805233df..aeafa195d 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,393 +1,396 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilController do
	use Pleroma.Web, :controller

	require Logger

	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Emoji
	alias Pleroma.Healthcheck
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.Auth.WrapperAuthenticator, as: Authenticator
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug
	alias Pleroma.Web.WebFinger

	plug(
	Pleroma.Web.ApiSpec.CastAndValidate,
	[replace_params: false]
	when action != :remote_subscribe and action != :show_subscribe_form
	)

	plug(
	Pleroma.Web.Plugs.FederatingPlug
	when action == :remote_subscribe
	when action == :show_subscribe_form
	)

	plug(
	OAuthScopesPlug,
	%{scopes: ["write:accounts"]}
	when action in [
	:change_email,
	:change_password,
	:delete_account,
	:update_notification_settings,
	:disable_account,
	:move_account,
	:add_alias,
	:delete_alias
	]
	)

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

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

	def show_subscribe_form(conn, %{"nickname" => nick}) do
	with %User{} = user <- User.get_cached_by_nickname(nick),
	avatar = User.avatar_url(user) do
	conn
	\|> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"remote follow error message - user not found",
	"Could not find user"
	)
	})
	end
	end

	def show_subscribe_form(conn, %{"status_id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	{:ok, ap_id} <- get_ap_id(activity),
	%User{} = user <- User.get_cached_by_ap_id(activity.actor),
	avatar = User.avatar_url(user) do
	conn
	\|> render("status_interact.html", %{
	status_link: ap_id,
	status_id: id,
	nickname: user.nickname,
	avatar: avatar,
	error: false
	})
	else
	_e ->
	render(conn, "status_interact.html", %{
	status_id: id,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"status interact error message - status not found",
	"Could not find status"
	)
	})
	end
	end

	def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
	show_subscribe_form(conn, %{"nickname" => nick})
	end

	def remote_subscribe(conn, %{"status_id" => id, "profile" => _}) do
	show_subscribe_form(conn, %{"status_id" => id})
	end

	def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"remote follow error message - unknown error",
	"Something went wrong."
	)
	})
	end
	end

	def remote_subscribe(conn, %{"status" => %{"status_id" => id, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%Activity{} = activity <- Activity.get_by_id(id),
	{:ok, ap_id} <- get_ap_id(activity) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "status_interact.html", %{
	status_id: id,
	avatar: nil,
	error:
	Pleroma.Web.Gettext.dpgettext(
	"static_pages",
	"status interact error message - unknown error",
	"Something went wrong."
	)
	})
	end
	end

	def remote_interaction(
	%{private: %{open_api_spex: %{body_params: %{ap_id: ap_id, profile: profile}}}} = conn,
	_params
	) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile) do
	conn
	\|> json(%{url: String.replace(template, "{uri}", ap_id)})
	else
	_e -> json(conn, %{error: "Couldn't find user"})
	end
	end

	defp get_ap_id(activity) do
	object = Pleroma.Object.normalize(activity, fetch: false)

	case object do
	%{data: %{"id" => ap_id}} -> {:ok, ap_id}
	_ -> {:no_ap_id, nil}
	end
	end

	def frontend_configurations(conn, _params) do
	render(conn, "frontend_configurations.json")
	end

	def emoji(conn, _params) do
	emoji =
	Enum.reduce(Emoji.get_all(), %{}, fn {code, %Emoji{file: file, tags: tags}}, acc ->
	Map.put(acc, code, %{image_url: file, tags: tags})
	end)

	json(conn, emoji)
	end

	def update_notification_settings(%{assigns: %{user: user}} = conn, params) do
	with {:ok, _} <- User.update_notification_settings(user, params) do
	json(conn, %{status: "success"})
	end
	end

	def change_password(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	- case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	- {:ok, user} ->
	- with {:ok, _user} <-
	- User.reset_password(user, %{
	- password: body_params.new_password,
	- password_confirmation: body_params.new_password_confirmation
	- }) do
	- json(conn, %{status: "success"})
	- else
	- {:error, changeset} ->
	- {_, {error, _}} = Enum.at(changeset.errors, 0)
	- json(conn, %{error: "New password #{error}."})
	- end
	+ with {:ok, %User{}} <-
	+ Authenticator.change_password(
	+ user,
	+ body_params.password,
	+ body_params.new_password,
	+ body_params.new_password_confirmation
	+ ) do
	+ json(conn, %{status: "success"})
	+ else
	+ {:error, %Ecto.Changeset{} = changeset} ->
	+ {_, {error, _}} = Enum.at(changeset.errors, 0)
	+ json(conn, %{error: "New password #{error}."})
	+
	+ {:error, :password_confirmation} ->
	+ json(conn, %{error: "New password does not match confirmation."})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def change_email(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, _user} <- User.change_email(user, body_params.email) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "Email #{error}."})

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

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def delete_account(
	%{
	assigns: %{user: user},
	private: %{open_api_spex: %{body_params: body_params, params: params}}
	} = conn,
	_
	) do
	# This endpoint can accept a query param or JSON body for backwards-compatibility.
	# Submitting a JSON body is recommended, so passwords don't end up in server logs.
	password = body_params[:password] \|\| params[:password] \|\| ""

	case CommonAPI.Utils.confirm_current_password(user, password) do
	{:ok, user} ->
	User.delete(user)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def disable_account(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: params}}} = conn,
	_
	) do
	case CommonAPI.Utils.confirm_current_password(user, params[:password]) do
	{:ok, user} ->
	User.set_activation_async(user, false)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def move_account(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	case CommonAPI.Utils.confirm_current_password(user, body_params.password) do
	{:ok, user} ->
	with {:ok, target_user} <- find_or_fetch_user_by_nickname(body_params.target_account),
	{:ok, _user} <- ActivityPub.move(user, target_user) do
	json(conn, %{status: "success"})
	else
	{:not_found, _} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Target account not found."})

	{:error, error} ->
	json(conn, %{error: error})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def add_alias(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	with {:ok, alias_user} <- find_user_by_nickname(body_params.alias),
	{:ok, _user} <- user \|> User.add_alias(alias_user) do
	json(conn, %{status: "success"})
	else
	{:not_found, _} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Target account does not exist."})

	{:error, error} ->
	json(conn, %{error: error})
	end
	end

	def delete_alias(
	%{assigns: %{user: user}, private: %{open_api_spex: %{body_params: body_params}}} = conn,
	_
	) do
	with {:ok, alias_user} <- find_user_by_nickname(body_params.alias),
	{:ok, _user} <- user \|> User.delete_alias(alias_user) do
	json(conn, %{status: "success"})
	else
	{:error, :no_such_alias} ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Account has no such alias."})

	{:error, error} ->
	json(conn, %{error: error})
	end
	end

	def list_aliases(%{assigns: %{user: user}} = conn, _) do
	alias_nicks =
	user
	\|> User.alias_users()
	\|> Enum.map(&User.full_nickname/1)

	json(conn, %{aliases: alias_nicks})
	end

	defp find_user_by_nickname(nickname) do
	user = User.get_cached_by_nickname(nickname)

	if user == nil do
	{:error, :not_found}
	else
	{:ok, user}
	end
	end

	defp find_or_fetch_user_by_nickname(nickname) do
	user = User.get_by_nickname(nickname)

	if user != nil and user.local do
	{:ok, user}
	else
	with {:ok, user} <- User.fetch_by_nickname(nickname) do
	{:ok, user}
	else
	_ ->
	{:not_found, nil}
	end
	end
	end

	def captcha(conn, _params) do
	json(conn, Pleroma.Captcha.new())
	end

	def healthcheck(conn, _params) do
	with {:cfg, true} <- {:cfg, Config.get([:instance, :healthcheck])},
	%{healthy: true} = info <- Healthcheck.system_info() do
	json(conn, info)
	else
	%{healthy: false} = info ->
	service_unavailable(conn, info)

	{:cfg, false} ->
	service_unavailable(conn, %{"error" => "Healthcheck disabled"})

	_ ->
	service_unavailable(conn, %{})
	end
	end

	defp service_unavailable(conn, info) do
	conn
	\|> put_status(:service_unavailable)
	\|> json(info)
	end
	end
	diff --git a/lib/pleroma/workers/poll_worker.ex b/lib/pleroma/workers/poll_worker.ex
	index d263aa1b9..a9afe9d63 100644
	--- a/lib/pleroma/workers/poll_worker.ex
	+++ b/lib/pleroma/workers/poll_worker.ex
	@@ -1,52 +1,77 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.PollWorker do
	@moduledoc """
	Generates notifications when a poll ends.
	"""
	use Oban.Worker, queue: :background

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	+ alias Pleroma.Object.Fetcher
	+
	+ @stream_out_impl Pleroma.Config.get(
	+ [__MODULE__, :stream_out],
	+ Pleroma.Web.ActivityPub.ActivityPub
	+ )

	@impl true
	def perform(%Job{args: %{"op" => "poll_end", "activity_id" => activity_id}}) do
	- with %Activity{} = activity <- find_poll_activity(activity_id),
	+ with {_, %Activity{} = activity} <- {:activity, Activity.get_by_id(activity_id)},
	{:ok, notifications} <- Notification.create_poll_notifications(activity) do
	+ unless activity.local do
	+ # Schedule a final refresh
	+ __MODULE__.new(%{"op" => "refresh", "activity_id" => activity_id})
	+ \|> Oban.insert()
	+ end
	+
	Notification.stream(notifications)
	else
	- {:error, :poll_activity_not_found} = e -> {:cancel, e}
	+ {:activity, nil} -> {:cancel, :poll_activity_not_found}
	e -> {:error, e}
	end
	end

	- @impl true
	- def timeout(_job), do: :timer.seconds(5)
	+ def perform(%Job{args: %{"op" => "refresh", "activity_id" => activity_id}}) do
	+ with {_, %Activity{object: object}} <-
	+ {:activity, Activity.get_by_id_with_object(activity_id)},
	+ {_, {:ok, _object}} <- {:refetch, Fetcher.refetch_object(object)} do
	+ stream_update(activity_id)

	- defp find_poll_activity(activity_id) do
	- with nil <- Activity.get_by_id(activity_id) do
	- {:error, :poll_activity_not_found}
	+ :ok
	+ else
	+ {:activity, nil} -> {:cancel, :poll_activity_not_found}
	+ {:refetch, _} = e -> {:cancel, e}
	end
	end

	+ @impl true
	+ def timeout(_job), do: :timer.seconds(5)
	+
	def schedule_poll_end(%Activity{data: %{"type" => "Create"}, id: activity_id} = activity) do
	with %Object{data: %{"type" => "Question", "closed" => closed}} when is_binary(closed) <-
	Object.normalize(activity),
	{:ok, end_time} <- NaiveDateTime.from_iso8601(closed),
	:gt <- NaiveDateTime.compare(end_time, NaiveDateTime.utc_now()) do
	%{
	op: "poll_end",
	activity_id: activity_id
	}
	\|> new(scheduled_at: end_time)
	\|> Oban.insert()
	else
	_ -> {:error, activity}
	end
	end

	def schedule_poll_end(activity), do: {:error, activity}
	+
	+ defp stream_update(activity_id) do
	+ Activity.get_by_id(activity_id)
	+ \|> Activity.normalize()
	+ \|> @stream_out_impl.stream_out()
	+ end
	end
	diff --git a/mix.exs b/mix.exs
	index ceae5c26d..89ec5e831 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,373 +1,373 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("2.7.0"),
	- elixir: "~> 1.13",
	+ elixir: "~> 1.14",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: Mix.compilers(),
	elixirc_options: [warnings_as_errors: warnings_as_errors(), prune_code_paths: false],
	xref: [exclude: [:eldap]],
	dialyzer: [plt_add_apps: [:mix, :eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: :covertool, summary: true],
	# Docs
	name: "Pleroma",
	homepage_url: "https://pleroma.social/",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	docs: [
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	logo: "priv/static/images/logo.png",
	extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/*/.md"),
	groups_for_extras: [
	"Installation manuals": Path.wildcard("docs/installation/*.md"),
	Configuration: Path.wildcard("docs/config/*.md"),
	Administration: Path.wildcard("docs/admin/*.md"),
	"Pleroma's APIs and Mastodon API extensions": Path.wildcard("docs/api/*.md")
	],
	main: "readme",
	output: "priv/static/doc"
	],
	releases: [
	pleroma: [
	include_executables_for: [:unix],
	applications: [ex_syslogger: :load, syslog: :load, eldap: :transient],
	steps: [:assemble, &put_otp_version/1, &copy_files/1, &copy_nginx_config/1],
	config_providers: [{Pleroma.Config.ReleaseRuntimeProvider, []}]
	]
	]
	]
	end

	def put_otp_version(%{path: target_path} = release) do
	File.write!(
	Path.join([target_path, "OTP_VERSION"]),
	Pleroma.OTPVersion.version()
	)

	release
	end

	def copy_files(%{path: target_path} = release) do
	File.cp_r!("./rel/files", target_path)
	release
	end

	def copy_nginx_config(%{path: target_path} = release) do
	File.cp!(
	"./installation/pleroma.nginx",
	Path.join([target_path, "installation", "pleroma.nginx"])
	)

	release
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[
	mod: {Pleroma.Application, []},
	extra_applications:
	[
	:logger,
	:runtime_tools,
	:comeonin,
	:fast_sanitize,
	:os_mon,
	:ssl,
	:eldap
	] ++ logger_application(),
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:benchmark), do: ["lib", "benchmarks", "priv/scrubbers"]
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	defp warnings_as_errors, do: System.get_env("CI") == "true"

	# Specifies OAuth dependencies.
	defp oauth_deps do
	oauth_strategy_packages =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(fn strategy_entry ->
	with [_strategy, dependency] <- String.split(strategy_entry, ":") do
	dependency
	else
	[strategy] -> "ueberauth_#{strategy}"
	end
	end)

	for s <- oauth_strategy_packages, do: {String.to_atom(s), ">= 0.0.0"}
	end

	defp logger_application do
	if Version.match?(System.version(), "<1.15.0-rc.0") do
	[]
	else
	[:logger_backends]
	end
	end

	defp logger_deps do
	if Version.match?(System.version(), "<1.15.0-rc.0") do
	[]
	else
	[{:logger_backends, "~> 1.0"}]
	end
	end

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix, "~> 1.7.3"},
	{:phoenix_ecto, "~> 4.4"},
	{:ecto_sql, "~> 3.10"},
	{:ecto_enum, "~> 1.4"},
	{:postgrex, ">= 0.0.0"},
	{:phoenix_html, "~> 3.3"},
	{:phoenix_live_view, "~> 0.19.0"},
	{:phoenix_live_dashboard, "~> 0.8.0"},
	{:telemetry_metrics, "~> 0.6"},
	{:telemetry_poller, "~> 1.0"},
	{:tzdata, "~> 1.0.3"},
	{:plug_cowboy, "~> 2.5"},
	{:oban, "~> 2.18.0"},
	{:gettext, "~> 0.20"},
	{:bcrypt_elixir, "~> 2.2"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:fast_sanitize, "~> 0.2.0"},
	{:html_entities, "~> 0.5", override: true},
	{:calendar, "~> 1.0"},
	{:cachex, "~> 3.2"},
	{:tesla, "~> 1.11"},
	{:castore, "~> 1.0"},
	{:cowlib, "~> 2.9", override: true},
	{:gun, "~> 2.0.0-rc.1", override: true},
	{:finch, "~> 0.15"},
	{:jason, "~> 1.2"},
	{:mogrify, "~> 0.9.0", override: "true"},
	{:ex_aws, "~> 2.1.6"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.7.2"},
	{:earmark, "1.4.46"},
	{:bbcode_pleroma, "~> 0.2.0"},
	{:cors_plug, "~> 2.0"},
	{:web_push_encryption, "~> 0.3.1"},
	{:swoosh, "~> 1.16.9"},
	{:phoenix_swoosh, "~> 1.1"},
	{:gen_smtp, "~> 0.13"},
	{:mua, "~> 0.2.0"},
	{:mail, "~> 0.3.0"},
	{:ex_syslogger, "~> 1.4"},
	{:floki, "~> 0.35"},
	{:timex, "~> 3.6"},
	{:ueberauth, "~> 0.4"},
	{:linkify, "~> 0.5.3"},
	{:http_signatures, "~> 0.1.2"},
	{:telemetry, "~> 1.0.0", override: true},
	{:poolboy, "~> 1.5"},
	{:prom_ex, "~> 1.9"},
	{:recon, "~> 2.5"},
	{:joken, "~> 2.0"},
	{:pot, "~> 1.0"},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:flake_id, "~> 0.1.0"},
	{:concurrent_limiter, "~> 0.1.1"},
	{:remote_ip,
	git: "https://git.pleroma.social/pleroma/remote_ip.git",
	ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"},
	{:captcha,
	git: "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git",
	ref: "6630c42aaaab124e697b4e513190c89d8b64e410"},
	{:restarter, path: "./restarter"},
	{:majic, "~> 1.0"},
	{:open_api_spex, "~> 3.16"},
	{:ecto_psql_extras, "~> 0.6"},
	{:vix, "~> 0.26.0"},
	{:elixir_make, "~> 0.7.7", override: true},
	{:blurhash, "~> 0.1.0", hex: :rinpatch_blurhash},
	{:exile, "~> 0.10.0"},
	{:bandit, "~> 1.5.2"},
	{:websock_adapter, "~> 0.5.6"},
	{:oban_live_dashboard, "~> 0.1.1"},
	{:multipart, "~> 0.4.0", optional: true},
	{:argon2_elixir, "~> 4.0"},

	## dev & test
	{:phoenix_live_reload, "~> 1.3.3", only: :dev},
	{:poison, "~> 3.0", only: :test},
	{:ex_doc, "~> 0.22", only: :dev, runtime: false},
	{:ex_machina, "~> 2.4", only: :test},
	{:credo, "~> 1.6", only: [:dev, :test], runtime: false},
	{:mock, "~> 0.3.5", only: :test},
	{:covertool, "~> 2.0", only: :test},
	{:hackney, "~> 1.18.0", override: true},
	{:mox, "~> 1.0", only: :test},
	{:websockex, "~> 0.4.3", only: :test},
	{:benchee, "~> 1.0", only: :benchmark},
	{:dialyxir, "~> 1.4", only: [:dev, :test], runtime: false}
	] ++ oauth_deps() ++ logger_deps()
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.migrate": ["pleroma.ecto.migrate"],
	"ecto.rollback": ["pleroma.ecto.rollback"],
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	test: ["ecto.create --quiet", "ecto.migrate", "test"],
	docs: ["pleroma.docs", "docs"],
	analyze: ["credo --strict --only=warnings,todo,fixme,consistency,readability"],
	copyright: &add_copyright/1,
	"copyright.bump": &bump_copyright/1
	]
	end

	# Builds a version string made of:
	# * the application version
	# * a pre-release if ahead of the tag: the describe string (-count-commithash)
	# * branch name
	# * build metadata:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	identifier_filter = ~r/[^0-9a-z\-]+/i

	git_available? = match?({_output, 0}, System.cmd("sh", ["-c", "command -v git"]))
	dotgit_present? = File.exists?(".git")

	git_pre_release =
	if git_available? and dotgit_present? do
	{tag, tag_err} =
	System.cmd("git", ["describe", "--tags", "--abbrev=0"], stderr_to_stdout: true)

	{describe, describe_err} = System.cmd("git", ["describe", "--tags", "--abbrev=8"])
	{commit_hash, commit_hash_err} = System.cmd("git", ["rev-parse", "--short", "HEAD"])

	# Pre-release version, denoted from patch version with a hyphen
	cond do
	tag_err == 0 and describe_err == 0 ->
	describe
	\|> String.trim()
	\|> String.replace(String.trim(tag), "")
	\|> String.trim_leading("-")
	\|> String.trim()

	commit_hash_err == 0 ->
	"0-g" <> String.trim(commit_hash)

	true ->
	nil
	end
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with true <- git_available?,
	true <- dotgit_present?,
	{branch_name, 0} <- System.cmd("git", ["rev-parse", "--abbrev-ref", "HEAD"]),
	branch_name <- String.trim(branch_name),
	branch_name <- System.get_env("PLEROMA_BUILD_BRANCH") \|\| branch_name,
	true <-
	!Enum.any?(["master", "HEAD", "release/", "stable"], fn name ->
	String.starts_with?(name, branch_name)
	end) do
	branch_name =
	branch_name
	\|> String.trim()
	\|> String.replace(identifier_filter, "-")

	branch_name
	else
	_ -> ""
	end

	build_name =
	cond do
	name = Application.get_env(:pleroma, :build_name) -> name
	name = System.get_env("PLEROMA_BUILD_NAME") -> name
	true -> nil
	end

	env_name = if Mix.env() != :prod, do: to_string(Mix.env())
	env_override = System.get_env("PLEROMA_BUILD_ENV")

	env_name =
	case env_override do
	nil -> env_name
	env_override when env_override in ["", "prod"] -> nil
	env_override -> env_override
	end

	# Pre-release version, denoted by appending a hyphen
	# and a series of dot separated identifiers
	pre_release =
	[git_pre_release, branch_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "-" <> String.replace(string, identifier_filter, "-")
	end).()

	# Build metadata, denoted with a plus sign
	build_metadata =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "+" <> String.replace(string, identifier_filter, "-")
	end).()

	[version, pre_release, build_metadata]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end

	defp add_copyright(_) do
	year = NaiveDateTime.utc_now().year
	template = ~s[\
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	] \|> String.replace("\n", "\\n")

	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$ -exec "
	grep = "grep -L '# Copyright © [0-9\-]* Pleroma' {} \\;"
	xargs = "xargs -n1 sed -i'' '1s;^;#{template};'"

	:os.cmd(String.to_charlist("#{find}#{grep} \| #{xargs}"))
	end

	defp bump_copyright(_) do
	year = NaiveDateTime.utc_now().year
	find = "find lib test priv -type f \$ -name '.ex' -or -name '.exs' \$"

	xargs =
	"xargs sed -i'' 's;# Copyright © [0-9\-]* Pleroma.*$;# Copyright © 2017-#{year} Pleroma Authors <https://pleroma.social/>;'"

	:os.cmd(String.to_charlist("#{find} \| #{xargs}"))
	end
	end
	diff --git a/mix.lock b/mix.lock
	index 2cf44862b..421f99ec0 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,156 +1,156 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm", "11b18c220bcc2eab63b5470c038ef10eb6783bcb1fcdb11aa4137defa5ac1bb8"},
	"argon2_elixir": {:hex, :argon2_elixir, "4.0.0", "7f6cd2e4a93a37f61d58a367d82f830ad9527082ff3c820b8197a8a736648941", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "f9da27cf060c9ea61b1bd47837a28d7e48a8f6fa13a745e252556c14f9132c7f"},
	"bandit": {:hex, :bandit, "1.5.5", "df28f1c41f745401fe9e85a6882033f5f3442ab6d30c8a2948554062a4ab56e0", [:mix], [{:hpax, "~> 0.2.0", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.0", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "f21579a29ea4bc08440343b2b5f16f7cddf2fea5725d31b72cf973ec729079e1"},
	"base62": {:hex, :base62, "1.2.2", "85c6627eb609317b70f555294045895ffaaeb1758666ab9ef9ca38865b11e629", [:mix], [{:custom_base, "~> 0.2.1", [hex: :custom_base, repo: "hexpm", optional: false]}], "hexpm", "d41336bda8eaa5be197f1e4592400513ee60518e5b9f4dcf38f4b4dae6f377bb"},
	"bbcode_pleroma": {:hex, :bbcode_pleroma, "0.2.0", "d36f5bca6e2f62261c45be30fa9b92725c0655ad45c99025cb1c3e28e25803ef", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "19851074419a5fedb4ef49e1f01b30df504bb5dbb6d6adfc135238063bebd1c3"},
	"bcrypt_elixir": {:hex, :bcrypt_elixir, "2.3.1", "5114d780459a04f2b4aeef52307de23de961b69e13a5cd98a911e39fda13f420", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "42182d5f46764def15bf9af83739e3bf4ad22661b1c34fc3e88558efced07279"},
	"benchee": {:hex, :benchee, "1.3.0", "f64e3b64ad3563fa9838146ddefb2d2f94cf5b473bdfd63f5ca4d0657bf96694", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.0", [hex: :statistex, repo: "hexpm", optional: false]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "34f4294068c11b2bd2ebf2c59aac9c7da26ffa0068afdf3419f1b176e16c5f81"},
	"blurhash": {:hex, :rinpatch_blurhash, "0.1.0", "01a888b0f5f1f382ab52e4396f01831cbe8486ea5828604c90f4dac533d39a4b", [:mix], [{:mogrify, "~> 0.8.0", [hex: :mogrify, repo: "hexpm", optional: true]}], "hexpm", "19911a5dcbb0acb9710169a72f702bce6cb048822b12de566ccd82b2cc42b907"},
	"bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},
	"cachex": {:hex, :cachex, "3.6.0", "14a1bfbeee060dd9bec25a5b6f4e4691e3670ebda28c8ba2884b12fe30b36bf8", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:jumper, "~> 1.0", [hex: :jumper, repo: "hexpm", optional: false]}, {:sleeplocks, "~> 1.1", [hex: :sleeplocks, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm", "ebf24e373883bc8e0c8d894a63bbe102ae13d918f790121f5cfe6e485cc8e2e2"},
	"calendar": {:hex, :calendar, "1.0.0", "f52073a708528482ec33d0a171954ca610fe2bd28f1e871f247dc7f1565fa807", [:mix], [{:tzdata, "~> 0.5.20 or ~> 0.1.201603 or ~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "990e9581920c82912a5ee50e62ff5ef96da6b15949a2ee4734f935fdef0f0a6f"},
	"captcha": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git", "6630c42aaaab124e697b4e513190c89d8b64e410", [ref: "6630c42aaaab124e697b4e513190c89d8b64e410"]},
	"castore": {:hex, :castore, "1.0.8", "dedcf20ea746694647f883590b82d9e96014057aff1d44d03ec90f36a5c0dc6e", [:mix], [], "hexpm", "0b2b66d2ee742cb1d9cb8c8be3b43c3a70ee8651f37b75a8b982e036752983f1"},
	"cc_precompiler": {:hex, :cc_precompiler, "0.1.9", "e8d3364f310da6ce6463c3dd20cf90ae7bbecbf6c5203b98bf9b48035592649b", [:mix], [{:elixir_make, "~> 0.7", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "9dcab3d0f3038621f1601f13539e7a9ee99843862e66ad62827b0c42b2f58a54"},
	"certifi": {:hex, :certifi, "2.12.0", "2d1cca2ec95f59643862af91f001478c9863c2ac9cb6e2f89780bfd8de987329", [:rebar3], [], "hexpm", "ee68d85df22e554040cdb4be100f33873ac6051387baf6a8f6ce82272340ff1c"},
	"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
	"comeonin": {:hex, :comeonin, "5.4.0", "246a56ca3f41d404380fc6465650ddaa532c7f98be4bda1b4656b3a37cc13abe", [:mix], [], "hexpm", "796393a9e50d01999d56b7b8420ab0481a7538d0caf80919da493b4a6e51faf1"},
	"concurrent_limiter": {:hex, :concurrent_limiter, "0.1.1", "43ae1dc23edda1ab03dd66febc739c4ff710d047bb4d735754909f9a474ae01c", [:mix], [{:telemetry, "~> 0.3", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "53968ff238c0fbb4d7ed76ddb1af0be6f3b2f77909f6796e249e737c505a16eb"},
	"connection": {:hex, :connection, "1.1.0", "ff2a49c4b75b6fb3e674bfc5536451607270aac754ffd1bdfe175abe4a6d7a68", [:mix], [], "hexpm", "722c1eb0a418fbe91ba7bd59a47e28008a189d47e37e0e7bb85585a016b2869c"},
	"cors_plug": {:hex, :cors_plug, "2.0.3", "316f806d10316e6d10f09473f19052d20ba0a0ce2a1d910ddf57d663dac402ae", [:mix], [{:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "ee4ae1418e6ce117fc42c2ba3e6cbdca4e95ecd2fe59a05ec6884ca16d469aea"},
	"covertool": {:hex, :covertool, "2.0.6", "4a291b4e3449025b0595d8f44c8d7635d4f48f033be2ce88d22a329f36f94a91", [:rebar3], [], "hexpm", "5db3fcd82180d8ea4ad857d4d1ab21a8d31b5aee0d60d2f6c0f9e25a411d1e21"},
	"cowboy": {:hex, :cowboy, "2.12.0", "f276d521a1ff88b2b9b4c54d0e753da6c66dd7be6c9fca3d9418b561828a3731", [:make, :rebar3], [{:cowlib, "2.13.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "8a7abe6d183372ceb21caa2709bec928ab2b72e18a3911aa1771639bef82651e"},
	"cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"},
	"cowlib": {:hex, :cowlib, "2.13.0", "db8f7505d8332d98ef50a3ef34b34c1afddec7506e4ee4dd4a3a266285d282ca", [:make, :rebar3], [], "hexpm", "e1e1284dc3fc030a64b1ad0d8382ae7e99da46c3246b815318a4b848873800a4"},
	"credo": {:hex, :credo, "1.7.7", "771445037228f763f9b2afd612b6aa2fd8e28432a95dbbc60d8e03ce71ba4446", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "8bc87496c9aaacdc3f90f01b7b0582467b69b4bd2441fe8aae3109d843cc2f2e"},
	"crontab": {:hex, :crontab, "1.1.8", "2ce0e74777dfcadb28a1debbea707e58b879e6aa0ffbf9c9bb540887bce43617", [:mix], [{:ecto, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	"custom_base": {:hex, :custom_base, "0.2.1", "4a832a42ea0552299d81652aa0b1f775d462175293e99dfbe4d7dbaab785a706", [:mix], [], "hexpm", "8df019facc5ec9603e94f7270f1ac73ddf339f56ade76a721eaa57c1493ba463"},
	"db_connection": {:hex, :db_connection, "2.7.0", "b99faa9291bb09892c7da373bb82cba59aefa9b36300f6145c5f201c7adf48ec", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "dcf08f31b2701f857dfc787fbad78223d61a32204f217f15e881dd93e4bdd3ff"},
	"decimal": {:hex, :decimal, "2.1.1", "5611dca5d4b2c3dd497dec8f68751f1f1a54755e8ed2a966c2633cf885973ad6", [:mix], [], "hexpm", "53cfe5f497ed0e7771ae1a475575603d77425099ba5faef9394932b35020ffcc"},
	"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
	"dialyxir": {:hex, :dialyxir, "1.4.3", "edd0124f358f0b9e95bfe53a9fcf806d615d8f838e2202a9f430d59566b6b53b", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "bf2cfb75cd5c5006bec30141b131663299c661a864ec7fbbc72dfa557487a986"},
	"earmark": {:hex, :earmark, "1.4.46", "8c7287bd3137e99d26ae4643e5b7ef2129a260e3dcf41f251750cb4563c8fb81", [:mix], [], "hexpm", "798d86db3d79964e759ddc0c077d5eb254968ed426399fbf5a62de2b5ff8910a"},
	"earmark_parser": {:hex, :earmark_parser, "1.4.39", "424642f8335b05bb9eb611aa1564c148a8ee35c9c8a8bba6e129d51a3e3c6769", [:mix], [], "hexpm", "06553a88d1f1846da9ef066b87b57c6f605552cfbe40d20bd8d59cc6bde41944"},
	"eblurhash": {:git, "https://github.com/zotonic/eblurhash.git", "bc37ceb426ef021ee9927fb249bb93f7059194ab", [ref: "bc37ceb426ef021ee9927fb249bb93f7059194ab"]},
	"ecto": {:hex, :ecto, "3.11.2", "e1d26be989db350a633667c5cda9c3d115ae779b66da567c68c80cfb26a8c9ee", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3c38bca2c6f8d8023f2145326cc8a80100c3ffe4dcbd9842ff867f7fc6156c65"},
	"ecto_enum": {:hex, :ecto_enum, "1.4.0", "d14b00e04b974afc69c251632d1e49594d899067ee2b376277efd8233027aec8", [:mix], [{:ecto, ">= 3.0.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "> 3.0.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:mariaex, ">= 0.0.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, ">= 0.0.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "8fb55c087181c2b15eee406519dc22578fa60dd82c088be376d0010172764ee4"},
	"ecto_psql_extras": {:hex, :ecto_psql_extras, "0.7.15", "0fc29dbae0e444a29bd6abeee4cf3c4c037e692a272478a234a1cc765077dbb1", [:mix], [{:ecto_sql, "~> 3.7", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0", [hex: :postgrex, repo: "hexpm", optional: false]}, {:table_rex, "~> 3.1.1 or ~> 4.0.0", [hex: :table_rex, repo: "hexpm", optional: false]}], "hexpm", "b6127f3a5c6fc3d84895e4768cc7c199f22b48b67d6c99b13fbf4a374e73f039"},
	"ecto_sql": {:hex, :ecto_sql, "3.11.3", "4eb7348ff8101fbc4e6bbc5a4404a24fecbe73a3372d16569526b0cf34ebc195", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.11.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e5f36e3d736b99c7fee3e631333b8394ade4bafe9d96d35669fca2d81c2be928"},
	"eimp": {:hex, :eimp, "1.0.14", "fc297f0c7e2700457a95a60c7010a5f1dcb768a083b6d53f49cd94ab95a28f22", [:rebar3], [{:p1_utils, "1.0.18", [hex: :p1_utils, repo: "hexpm", optional: false]}], "hexpm", "501133f3112079b92d9e22da8b88bf4f0e13d4d67ae9c15c42c30bd25ceb83b6"},
	"elixir_make": {:hex, :elixir_make, "0.7.8", "505026f266552ee5aabca0b9f9c229cbb496c689537c9f922f3eb5431157efc7", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:certifi, "~> 2.0", [hex: :certifi, repo: "hexpm", optional: true]}], "hexpm", "7a71945b913d37ea89b06966e1342c85cfe549b15e6d6d081e8081c493062c07"},
	"erlex": {:hex, :erlex, "0.2.6", "c7987d15e899c7a2f34f5420d2a2ea0d659682c06ac607572df55a43753aa12e", [:mix], [], "hexpm", "2ed2e25711feb44d52b17d2780eabf998452f6efda104877a3881c2f8c0c0c75"},
	"esbuild": {:hex, :esbuild, "0.5.0", "d5bb08ff049d7880ee3609ed5c4b864bd2f46445ea40b16b4acead724fb4c4a3", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}], "hexpm", "f183a0b332d963c4cfaf585477695ea59eef9a6f2204fdd0efa00e099694ffe5"},
	"eternal": {:hex, :eternal, "1.2.2", "d1641c86368de99375b98d183042dd6c2b234262b8d08dfd72b9eeaafc2a1abd", [:mix], [], "hexpm", "2c9fe32b9c3726703ba5e1d43a1d255a4f3f2d8f8f9bc19f094c7cb1a7a9e782"},
	"ex_aws": {:hex, :ex_aws, "2.1.9", "dc4865ecc20a05190a34a0ac5213e3e5e2b0a75a0c2835e923ae7bfeac5e3c31", [:mix], [{:configparser_ex, "~> 4.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:jsx, "~> 3.0", [hex: :jsx, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "3e6c776703c9076001fbe1f7c049535f042cb2afa0d2cbd3b47cbc4e92ac0d10"},
	"ex_aws_s3": {:hex, :ex_aws_s3, "2.5.3", "422468e5c3e1a4da5298e66c3468b465cfd354b842e512cb1f6fbbe4e2f5bdaf", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "4f09dd372cc386550e484808c5ac5027766c8d0cd8271ccc578b82ee6ef4f3b8"},
	"ex_const": {:hex, :ex_const, "0.2.4", "d06e540c9d834865b012a17407761455efa71d0ce91e5831e86881b9c9d82448", [:mix], [], "hexpm", "96fd346610cc992b8f896ed26a98be82ac4efb065a0578f334a32d60a3ba9767"},
	"ex_doc": {:hex, :ex_doc, "0.31.1", "8a2355ac42b1cc7b2379da9e40243f2670143721dd50748bf6c3b1184dae2089", [:mix], [{:earmark_parser, "~> 1.4.39", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.1", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "3178c3a407c557d8343479e1ff117a96fd31bafe52a039079593fb0524ef61b0"},
	"ex_machina": {:hex, :ex_machina, "2.7.0", "b792cc3127fd0680fecdb6299235b4727a4944a09ff0fa904cc639272cd92dc7", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm", "419aa7a39bde11894c87a615c4ecaa52d8f107bbdd81d810465186f783245bf8"},
	"ex_syslogger": {:hex, :ex_syslogger, "1.5.2", "72b6aa2d47a236e999171f2e1ec18698740f40af0bd02c8c650bf5f1fd1bac79", [:mix], [{:poison, ">= 1.5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:syslog, "~> 1.1.0", [hex: :syslog, repo: "hexpm", optional: false]}], "hexpm", "ab9fab4136dbc62651ec6f16fa4842f10cf02ab4433fa3d0976c01be99398399"},
	"exile": {:hex, :exile, "0.10.0", "b69e2d27a9af670b0f0a0898addca0eda78f6f5ba95ccfbc9bc6ccdd04925436", [:make, :mix], [{:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "c62ee8fee565b5ac4a898d0dcd58d2b04fb5eec1655af1ddcc9eb582c6732c33"},
	"expo": {:hex, :expo, "0.5.1", "249e826a897cac48f591deba863b26c16682b43711dd15ee86b92f25eafd96d9", [:mix], [], "hexpm", "68a4233b0658a3d12ee00d27d37d856b1ba48607e7ce20fd376958d0ba6ce92b"},
	"fast_html": {:hex, :fast_html, "2.2.0", "6c5ef1be087a4ed613b0379c13f815c4d11742b36b67bb52cee7859847c84520", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}], "hexpm", "064c4f23b4a6168f9187dac8984b056f2c531bb0787f559fd6a8b34b38aefbae"},
	"fast_sanitize": {:hex, :fast_sanitize, "0.2.3", "67b93dfb34e302bef49fec3aaab74951e0f0602fd9fa99085987af05bd91c7a5", [:mix], [{:fast_html, "~> 2.0", [hex: :fast_html, repo: "hexpm", optional: false]}, {:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "e8ad286d10d0386e15d67d0ee125245ebcfbc7d7290b08712ba9013c8c5e56e2"},
	"file_system": {:hex, :file_system, "0.2.10", "fb082005a9cd1711c05b5248710f8826b02d7d1784e7c3451f9c1231d4fc162d", [:mix], [], "hexpm", "41195edbfb562a593726eda3b3e8b103a309b733ad25f3d642ba49696bf715dc"},
	"finch": {:hex, :finch, "0.18.0", "944ac7d34d0bd2ac8998f79f7a811b21d87d911e77a786bc5810adb75632ada4", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.3", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.6 or ~> 1.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "69f5045b042e531e53edc2574f15e25e735b522c37e2ddb766e15b979e03aa65"},
	"flake_id": {:hex, :flake_id, "0.1.0", "7716b086d2e405d09b647121a166498a0d93d1a623bead243e1f74216079ccb3", [:mix], [{:base62, "~> 1.2", [hex: :base62, repo: "hexpm", optional: false]}, {:ecto, ">= 2.0.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm", "31fc8090fde1acd267c07c36ea7365b8604055f897d3a53dd967658c691bd827"},
	"floki": {:hex, :floki, "0.35.2", "87f8c75ed8654b9635b311774308b2760b47e9a579dabf2e4d5f1e1d42c39e0b", [:mix], [], "hexpm", "6b05289a8e9eac475f644f09c2e4ba7e19201fd002b89c28c1293e7bd16773d9"},
	"gen_smtp": {:hex, :gen_smtp, "0.15.0", "9f51960c17769b26833b50df0b96123605a8024738b62db747fece14eb2fbfcc", [:rebar3], [], "hexpm", "29bd14a88030980849c7ed2447b8db6d6c9278a28b11a44cafe41b791205440f"},
	"gettext": {:hex, :gettext, "0.24.0", "6f4d90ac5f3111673cbefc4ebee96fe5f37a114861ab8c7b7d5b30a1108ce6d8", [:mix], [{:expo, "~> 0.5.1", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "bdf75cdfcbe9e4622dd18e034b227d77dd17f0f133853a1c73b97b3d6c770e8b"},
	"gun": {:hex, :gun, "2.0.1", "160a9a5394800fcba41bc7e6d421295cf9a7894c2252c0678244948e3336ad73", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}], "hexpm", "a10bc8d6096b9502205022334f719cc9a08d9adcfbfc0dbee9ef31b56274a20b"},
	"hackney": {:hex, :hackney, "1.18.2", "d7ff544ddae5e1cb49e9cf7fa4e356d7f41b283989a1c304bfc47a8cc1cf966f", [:rebar3], [{:certifi, "~>2.12.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~>6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~>1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.4.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~>1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "af94d5c9f97857db257090a4a10e5426ecb6f4918aa5cc666798566ae14b65fd"},
	"hpax": {:hex, :hpax, "0.2.0", "5a58219adcb75977b2edce5eb22051de9362f08236220c9e859a47111c194ff5", [:mix], [], "hexpm", "bea06558cdae85bed075e6c036993d43cd54d447f76d8190a8db0dc5893fa2f1"},
	"html_entities": {:hex, :html_entities, "0.5.2", "9e47e70598da7de2a9ff6af8758399251db6dbb7eebe2b013f2bbd2515895c3c", [:mix], [], "hexpm", "c53ba390403485615623b9531e97696f076ed415e8d8058b1dbaa28181f4fdcc"},
	"http_signatures": {:hex, :http_signatures, "0.1.2", "ed1cc7043abcf5bb4f30d68fb7bad9d618ec1a45c4ff6c023664e78b67d9c406", [:mix], [], "hexpm", "f08aa9ac121829dae109d608d83c84b940ef2f183ae50f2dd1e9a8bc619d8be7"},
	"httpoison": {:hex, :httpoison, "1.8.2", "9eb9c63ae289296a544842ef816a85d881d4a31f518a0fec089aaa744beae290", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "2bb350d26972e30c96e2ca74a1aaf8293d61d0742ff17f01e0279fef11599921"},
	"idna": {:hex, :idna, "6.1.1", "8a63070e9f7d0c62eb9d9fcb360a7de382448200fbbd1b106cc96d3d8099df8d", [:rebar3], [{:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "92376eb7894412ed19ac475e4a86f7b413c1b9fbb5bd16dccd57934157944cea"},
	"inet_cidr": {:hex, :inet_cidr, "1.0.8", "d26bb7bdbdf21ae401ead2092bf2bb4bf57fe44a62f5eaa5025280720ace8a40", [:mix], [], "hexpm", "d5b26da66603bb56c933c65214c72152f0de9a6ea53618b56d63302a68f6a90e"},
	"jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"},
	"joken": {:hex, :joken, "2.6.0", "b9dd9b6d52e3e6fcb6c65e151ad38bf4bc286382b5b6f97079c47ade6b1bcc6a", [:mix], [{:jose, "~> 1.11.5", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "5a95b05a71cd0b54abd35378aeb1d487a23a52c324fa7efdffc512b655b5aaa7"},
	"jose": {:hex, :jose, "1.11.6", "613fda82552128aa6fb804682e3a616f4bc15565a048dabd05b1ebd5827ed965", [:mix, :rebar3], [], "hexpm", "6275cb75504f9c1e60eeacb771adfeee4905a9e182103aa59b53fed651ff9738"},
	"jumper": {:hex, :jumper, "1.0.2", "68cdcd84472a00ac596b4e6459a41b3062d4427cbd4f1e8c8793c5b54f1406a7", [:mix], [], "hexpm", "9b7782409021e01ab3c08270e26f36eb62976a38c1aa64b2eaf6348422f165e1"},
	"linkify": {:hex, :linkify, "0.5.3", "5f8143d8f61f5ff08d3aeeff47ef6509492b4948d8f08007fbf66e4d2246a7f2", [:mix], [], "hexpm", "3ef35a1377d47c25506e07c1c005ea9d38d700699d92ee92825f024434258177"},
	"logger_backends": {:hex, :logger_backends, "1.0.0", "09c4fad6202e08cb0fbd37f328282f16539aca380f512523ce9472b28edc6bdf", [:mix], [], "hexpm", "1faceb3e7ec3ef66a8f5746c5afd020e63996df6fd4eb8cdb789e5665ae6c9ce"},
	"mail": {:hex, :mail, "0.3.1", "cb0a14e4ed8904e4e5a08214e686ccf6f9099346885db17d8c309381f865cc5c", [:mix], [], "hexpm", "1db701e89865c1d5fa296b2b57b1cd587587cca8d8a1a22892b35ef5a8e352a6"},
	"majic": {:hex, :majic, "1.0.0", "37e50648db5f5c2ff0c9fb46454d034d11596c03683807b9fb3850676ffdaab3", [:make, :mix], [{:elixir_make, "~> 0.6.1", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "7905858f76650d49695f14ea55cd9aaaee0c6654fa391671d4cf305c275a0a9e"},
	"makeup": {:hex, :makeup, "1.0.5", "d5a830bc42c9800ce07dd97fa94669dfb93d3bf5fcf6ea7a0c67b2e0e4a7f26c", [:mix], [{:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "cfa158c02d3f5c0c665d0af11512fed3fba0144cf1aadee0f2ce17747fba2ca9"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.14.1", "4f0e96847c63c17841d42c08107405a005a2680eb9c7ccadfd757bd31dabccfb", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f2438b1a80eaec9ede832b5c41cd4f373b38fd7aa33e3b22d9db79e640cbde11"},
	"makeup_erlang": {:hex, :makeup_erlang, "0.1.3", "d684f4bac8690e70b06eb52dad65d26de2eefa44cd19d64a8095e1417df7c8fd", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "b78dc853d2e670ff6390b605d807263bf606da3c82be37f9d7f68635bd886fc9"},
	"meck": {:hex, :meck, "0.9.2", "85ccbab053f1db86c7ca240e9fc718170ee5bda03810a6292b5306bf31bae5f5", [:rebar3], [], "hexpm", "81344f561357dc40a8344afa53767c32669153355b626ea9fcbc8da6b3045826"},
	"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},
	"mime": {:hex, :mime, "1.6.0", "dabde576a497cef4bbdd60aceee8160e02a6c89250d6c0b29e56c0dfb00db3d2", [:mix], [], "hexpm", "31a1a8613f8321143dde1dafc36006a17d28d02bdfecb9e95a880fa7aabd19a7"},
	"mimerl": {:hex, :mimerl, "1.3.0", "d0cd9fc04b9061f82490f6581e0128379830e78535e017f7780f37fea7545726", [:rebar3], [], "hexpm", "a1e15a50d1887217de95f0b9b0793e32853f7c258a5cd227650889b38839fe9d"},
	"mint": {:hex, :mint, "1.6.1", "065e8a5bc9bbd46a41099dfea3e0656436c5cbcb6e741c80bd2bad5cd872446f", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "4fc518dcc191d02f433393a72a7ba3f6f94b101d094cb6bf532ea54c89423780"},
	"mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.8", "7046a306b71db2488ef54395eeb74df0a7f335a7caca4a3d3875d1fc81c884dd", [:mix], [{:meck, "~> 0.9.2", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm", "7fa82364c97617d79bb7d15571193fc0c4fe5afd0c932cef09426b3ee6fe2022"},
	"mogrify": {:hex, :mogrify, "0.9.3", "238c782f00271dace01369ad35ae2e9dd020feee3443b9299ea5ea6bed559841", [:mix], [], "hexpm", "0189b1e1de27455f2b9ae8cf88239cefd23d38de9276eb5add7159aea51731e6"},
	"mox": {:hex, :mox, "1.1.0", "0f5e399649ce9ab7602f72e718305c0f9cdc351190f72844599545e4996af73c", [:mix], [], "hexpm", "d44474c50be02d5b72131070281a5d3895c0e7a95c780e90bc0cfe712f633a13"},
	"mua": {:hex, :mua, "0.2.3", "46b29b7b2bb14105c0b7be9526f7c452df17a7841b30b69871c024a822ff551c", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}], "hexpm", "7fe861a87fcc06a980d3941bbcb2634e5f0f30fd6ad15ef6c0423ff9dc7e46de"},
	"multipart": {:hex, :multipart, "0.4.0", "634880a2148d4555d050963373d0e3bbb44a55b2badd87fa8623166172e9cda0", [:mix], [{:mime, "~> 1.2 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}], "hexpm", "3c5604bc2fb17b3137e5d2abdf5dacc2647e60c5cc6634b102cf1aef75a06f0a"},
	"nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"},
	"nimble_parsec": {:hex, :nimble_parsec, "0.6.0", "32111b3bf39137144abd7ba1cce0914533b2d16ef35e8abc5ec8be6122944263", [:mix], [], "hexpm", "27eac315a94909d4dc68bc07a4a83e06c8379237c5ea528a9acff4ca1c873c52"},
	"nimble_pool": {:hex, :nimble_pool, "0.2.6", "91f2f4c357da4c4a0a548286c84a3a28004f68f05609b4534526871a22053cde", [:mix], [], "hexpm", "1c715055095d3f2705c4e236c18b618420a35490da94149ff8b580a2144f653f"},
	"nodex": {:git, "https://git.pleroma.social/pleroma/nodex", "cb6730f943cfc6aad674c92161be23a8411f15d1", [ref: "cb6730f943cfc6aad674c92161be23a8411f15d1"]},
	- "oban": {:hex, :oban, "2.18.2", "583e78965ee15263ac968e38c983bad169ae55eadaa8e1e39912562badff93ba", [:mix], [{:ecto_sql, "~> 3.10", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:ecto_sqlite3, "~> 0.9", [hex: :ecto_sqlite3, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "9dd25fd35883a91ed995e9fe516e479344d3a8623dfe2b8c3fc8e5be0228ec3a"},
	+ "oban": {:hex, :oban, "2.18.3", "1608c04f8856c108555c379f2f56bc0759149d35fa9d3b825cb8a6769f8ae926", [:mix], [{:ecto_sql, "~> 3.10", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:ecto_sqlite3, "~> 0.9", [hex: :ecto_sqlite3, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "36ca6ca84ef6518f9c2c759ea88efd438a3c81d667ba23b02b062a0aa785475e"},
	"oban_live_dashboard": {:hex, :oban_live_dashboard, "0.1.1", "8aa4ceaf381c818f7d5c8185cc59942b8ac82ef0cf559881aacf8d3f8ac7bdd3", [:mix], [{:oban, "~> 2.15", [hex: :oban, repo: "hexpm", optional: false]}, {:phoenix_live_dashboard, "~> 0.7", [hex: :phoenix_live_dashboard, repo: "hexpm", optional: false]}], "hexpm", "16dc4ce9c9a95aa2e655e35ed4e675652994a8def61731a18af85e230e1caa63"},
	"octo_fetch": {:hex, :octo_fetch, "0.4.0", "074b5ecbc08be10b05b27e9db08bc20a3060142769436242702931c418695b19", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~> 1.1", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm", "cf8be6f40cd519d7000bb4e84adcf661c32e59369ca2827c4e20042eda7a7fc6"},
	"open_api_spex": {:hex, :open_api_spex, "3.18.2", "8c855e83bfe8bf81603d919d6e892541eafece3720f34d1700b58024dadde247", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0 or ~> 4.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "aa3e6dcfc0ad6a02596b2172662da21c9dd848dac145ea9e603f54e3d81b8d2b"},
	"parse_trans": {:hex, :parse_trans, "3.4.1", "6e6aa8167cb44cc8f39441d05193be6e6f4e7c2946cb2759f015f8c56b76e5ff", [:rebar3], [], "hexpm", "620a406ce75dada827b82e453c19cf06776be266f5a67cff34e1ef2cbb60e49a"},
	"pbkdf2_elixir": {:hex, :pbkdf2_elixir, "1.2.1", "9cbe354b58121075bd20eb83076900a3832324b7dd171a6895fab57b6bb2752c", [:mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}], "hexpm", "d3b40a4a4630f0b442f19eca891fcfeeee4c40871936fed2f68e1c4faa30481f"},
	"phoenix": {:hex, :phoenix, "1.7.14", "a7d0b3f1bc95987044ddada111e77bd7f75646a08518942c72a8440278ae7825", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "c7859bc56cc5dfef19ecfc240775dae358cbaa530231118a9e014df392ace61a"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "4.4.3", "86e9878f833829c3f66da03d75254c155d91d72a201eb56ae83482328dc7ca93", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "d36c401206f3011fefd63d04e8ef626ec8791975d9d107f9a0817d426f61ac07"},
	"phoenix_html": {:hex, :phoenix_html, "3.3.4", "42a09fc443bbc1da37e372a5c8e6755d046f22b9b11343bf885067357da21cb3", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "0249d3abec3714aff3415e7ee3d9786cb325be3151e6c4b3021502c585bf53fb"},
	"phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.8.3", "7ff51c9b6609470f681fbea20578dede0e548302b0c8bdf338b5a753a4f045bf", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.5", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:ecto_sqlite3_extras, "~> 1.1.7 or ~> 1.2.0", [hex: :ecto_sqlite3_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.19 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "f9470a0a8bae4f56430a23d42f977b5a6205fdba6559d76f932b876bfaec652d"},
	"phoenix_live_reload": {:hex, :phoenix_live_reload, "1.3.3", "3a53772a6118d5679bf50fc1670505a290e32a1d195df9e069d8c53ab040c054", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "766796676e5f558dbae5d1bdb066849673e956005e3730dfd5affd7a6da4abac"},
	"phoenix_live_view": {:hex, :phoenix_live_view, "0.19.5", "6e730595e8e9b8c5da230a814e557768828fd8dfeeb90377d2d8dbb52d4ec00a", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b2eaa0dd3cfb9bd7fb949b88217df9f25aed915e986a28ad5c8a0d054e7ca9d3"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.3", "3168d78ba41835aecad272d5e8cd51aa87a7ac9eb836eabc42f6e57538e3731d", [:mix], [], "hexpm", "bba06bc1dcfd8cb086759f0edc94a8ba2bc8896d5331a1e2c2902bf8e36ee502"},
	"phoenix_swoosh": {:hex, :phoenix_swoosh, "1.2.1", "b74ccaa8046fbc388a62134360ee7d9742d5a8ae74063f34eb050279de7a99e1", [:mix], [{:finch, "~> 0.8", [hex: :finch, repo: "hexpm", optional: true]}, {:hackney, "~> 1.10", [hex: :hackney, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_html, "~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_view, "~> 1.0 or ~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: false]}, {:swoosh, "~> 1.5", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm", "4000eeba3f9d7d1a6bf56d2bd56733d5cadf41a7f0d8ffe5bb67e7d667e204a2"},
	"phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
	"phoenix_view": {:hex, :phoenix_view, "2.0.4", "b45c9d9cf15b3a1af5fb555c674b525391b6a1fe975f040fb4d913397b31abf4", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "4e992022ce14f31fe57335db27a28154afcc94e9983266835bb3040243eb620b"},
	"plug": {:hex, :plug, "1.16.1", "40c74619c12f82736d2214557dedec2e9762029b2438d6d175c5074c933edc9d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a13ff6b9006b03d7e33874945b2755253841b238c34071ed85b0e86057f8cddc"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.7.1", "87677ffe3b765bc96a89be7960f81703223fe2e21efa42c125fcd0127dd9d6b2", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "02dbd5f9ab571b864ae39418db7811618506256f6d13b4a45037e5fe78dc5de3"},
	"plug_crypto": {:hex, :plug_crypto, "2.1.0", "f44309c2b06d249c27c8d3f65cfe08158ade08418cf540fd4f72d4d6863abb7b", [:mix], [], "hexpm", "131216a4b030b8f8ce0f26038bc4421ae60e4bb95c5cf5395e1421437824c4fa"},
	"plug_static_index_html": {:hex, :plug_static_index_html, "1.0.0", "840123d4d3975585133485ea86af73cb2600afd7f2a976f9f5fd8b3808e636a0", [:mix], [{:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "79fd4fcf34d110605c26560cbae8f23c603ec4158c08298bd4360fdea90bb5cf"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm", "fec8660eb7733ee4117b85f55799fd3833eb769a6df71ccf8903e8dc5447cfce"},
	"poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm", "dad79704ce5440f3d5a3681c8590b9dc25d1a561e8f5a9c995281012860901e3"},
	"postgrex": {:hex, :postgrex, "0.17.5", "0483d054938a8dc069b21bdd636bf56c487404c241ce6c319c1f43588246b281", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "50b8b11afbb2c4095a3ba675b4f055c416d0f3d7de6633a595fc131a828a67eb"},
	"pot": {:hex, :pot, "1.0.2", "13abb849139fdc04ab8154986abbcb63bdee5de6ed2ba7e1713527e33df923dd", [:rebar3], [], "hexpm", "78fe127f5a4f5f919d6ea5a2a671827bd53eb9d37e5b4128c0ad3df99856c2e0"},
	"prom_ex": {:hex, :prom_ex, "1.9.0", "63e6dda6c05cdeec1f26c48443dcc38ffd2118b3665ae8d2bd0e5b79f2aea03e", [:mix], [{:absinthe, ">= 1.6.0", [hex: :absinthe, repo: "hexpm", optional: true]}, {:broadway, ">= 1.0.2", [hex: :broadway, repo: "hexpm", optional: true]}, {:ecto, ">= 3.5.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:finch, "~> 0.15", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.2", [hex: :jason, repo: "hexpm", optional: false]}, {:oban, ">= 2.4.0", [hex: :oban, repo: "hexpm", optional: true]}, {:octo_fetch, "~> 0.3", [hex: :octo_fetch, repo: "hexpm", optional: false]}, {:phoenix, ">= 1.5.0", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, ">= 0.14.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, ">= 1.12.1", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, "~> 2.5 or ~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: false]}, {:telemetry, ">= 1.0.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}, {:telemetry_metrics_prometheus_core, "~> 1.0", [hex: :telemetry_metrics_prometheus_core, repo: "hexpm", optional: false]}, {:telemetry_poller, "~> 1.0", [hex: :telemetry_poller, repo: "hexpm", optional: false]}], "hexpm", "01f3d4f69ec93068219e686cc65e58a29c42bea5429a8ff4e2121f19db178ee6"},
	"prometheus": {:hex, :prometheus, "4.10.0", "792adbf0130ff61b5fa8826f013772af24b6e57b984445c8d602c8a0355704a1", [:mix, :rebar3], [{:quantile_estimator, "~> 0.2.1", [hex: :quantile_estimator, repo: "hexpm", optional: false]}], "hexpm", "2a99bb6dce85e238c7236fde6b0064f9834dc420ddbd962aac4ea2a3c3d59384"},
	"prometheus_ecto": {:hex, :prometheus_ecto, "1.4.3", "3dd4da1812b8e0dbee81ea58bb3b62ed7588f2eae0c9e97e434c46807ff82311", [:mix], [{:ecto, "~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "8d66289f77f913b37eda81fd287340c17e61a447549deb28efc254532b2bed82"},
	"prometheus_ex": {:git, "https://github.com/lanodan/prometheus.ex.git", "31f7fbe4b71b79ba27efc2a5085746c4011ceb8f", [branch: "fix/elixir-1.14"]},
	"prometheus_phoenix": {:hex, :prometheus_phoenix, "1.3.0", "c4b527e0b3a9ef1af26bdcfbfad3998f37795b9185d475ca610fe4388fdd3bb5", [:mix], [{:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.3 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "c4d1404ac4e9d3d963da601db2a7d8ea31194f0017057fabf0cfb9bf5a6c8c75"},
	"prometheus_phx": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/prometheus-phx.git", "9cd8f248c9381ffedc799905050abce194a97514", [branch: "no-logging"]},
	"prometheus_plugs": {:hex, :prometheus_plugs, "1.1.5", "25933d48f8af3a5941dd7b621c889749894d8a1082a6ff7c67cc99dec26377c5", [:mix], [{:accept, "~> 0.1", [hex: :accept, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}, {:prometheus_process_collector, "~> 1.1", [hex: :prometheus_process_collector, repo: "hexpm", optional: true]}], "hexpm", "0273a6483ccb936d79ca19b0ab629aef0dba958697c94782bb728b920dfc6a79"},
	"quantile_estimator": {:hex, :quantile_estimator, "0.2.1", "ef50a361f11b5f26b5f16d0696e46a9e4661756492c981f7b2229ef42ff1cd15", [:rebar3], [], "hexpm", "282a8a323ca2a845c9e6f787d166348f776c1d4a41ede63046d72d422e3da946"},
	"ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
	"recon": {:hex, :recon, "2.5.4", "05dd52a119ee4059fa9daa1ab7ce81bc7a8161a2f12e9d42e9d551ffd2ba901c", [:mix, :rebar3], [], "hexpm", "e9ab01ac7fc8572e41eb59385efeb3fb0ff5bf02103816535bacaedf327d0263"},
	"remote_ip": {:git, "https://git.pleroma.social/pleroma/remote_ip.git", "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8", [ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"]},
	"rustler": {:hex, :rustler, "0.30.0", "cefc49922132b072853fa9b0ca4dc2ffcb452f68fb73b779042b02d545e097fb", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:toml, "~> 0.6", [hex: :toml, repo: "hexpm", optional: false]}], "hexpm", "9ef1abb6a7dda35c47cfc649e6a5a61663af6cf842a55814a554a84607dee389"},
	"sleeplocks": {:hex, :sleeplocks, "1.1.2", "d45aa1c5513da48c888715e3381211c859af34bee9b8290490e10c90bb6ff0ca", [:rebar3], [], "hexpm", "9fe5d048c5b781d6305c1a3a0f40bb3dfc06f49bf40571f3d2d0c57eaa7f59a5"},
	"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.7", "354c321cf377240c7b8716899e182ce4890c5938111a1296add3ec74cf1715df", [:make, :mix, :rebar3], [], "hexpm", "fe4c190e8f37401d30167c8c405eda19469f34577987c76dde613e838bbc67f8"},
	"statistex": {:hex, :statistex, "1.0.0", "f3dc93f3c0c6c92e5f291704cf62b99b553253d7969e9a5fa713e5481cd858a5", [:mix], [], "hexpm", "ff9d8bee7035028ab4742ff52fc80a2aa35cece833cf5319009b52f1b5a86c27"},
	"sweet_xml": {:hex, :sweet_xml, "0.7.4", "a8b7e1ce7ecd775c7e8a65d501bc2cd933bff3a9c41ab763f5105688ef485d08", [:mix], [], "hexpm", "e7c4b0bdbf460c928234951def54fe87edf1a170f6896675443279e2dbeba167"},
	"swoosh": {:hex, :swoosh, "1.16.9", "20c6a32ea49136a4c19f538e27739bb5070558c0fa76b8a95f4d5d5ca7d319a1", [:mix], [{:bandit, ">= 1.0.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mua, "~> 0.2.0", [hex: :mua, repo: "hexpm", optional: true]}, {:multipart, "~> 0.4", [hex: :multipart, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:req, "~> 0.5 or ~> 1.0", [hex: :req, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "878b1a7a6c10ebbf725a3349363f48f79c5e3d792eb621643b0d276a38acc0a6"},
	"syslog": {:hex, :syslog, "1.1.0", "6419a232bea84f07b56dc575225007ffe34d9fdc91abe6f1b2f254fd71d8efc2", [:rebar3], [], "hexpm", "4c6a41373c7e20587be33ef841d3de6f3beba08519809329ecc4d27b15b659e1"},
	"table_rex": {:hex, :table_rex, "4.0.0", "3c613a68ebdc6d4d1e731bc973c233500974ec3993c99fcdabb210407b90959b", [:mix], [], "hexpm", "c35c4d5612ca49ebb0344ea10387da4d2afe278387d4019e4d8111e815df8f55"},
	"telemetry": {:hex, :telemetry, "1.0.0", "0f453a102cdf13d506b7c0ab158324c337c41f1cc7548f0bc0e130bbf0ae9452", [:rebar3], [], "hexpm", "73bc09fa59b4a0284efb4624335583c528e07ec9ae76aca96ea0673850aec57a"},
	"telemetry_metrics": {:hex, :telemetry_metrics, "0.6.2", "2caabe9344ec17eafe5403304771c3539f3b6e2f7fb6a6f602558c825d0d0bfb", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "9b43db0dc33863930b9ef9d27137e78974756f5f198cae18409970ed6fa5b561"},
	"telemetry_metrics_prometheus_core": {:hex, :telemetry_metrics_prometheus_core, "1.2.0", "b583c3f18508f5c5561b674d16cf5d9afd2ea3c04505b7d92baaeac93c1b8260", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "9cba950e1c4733468efbe3f821841f34ac05d28e7af7798622f88ecdbbe63ea3"},
	"telemetry_poller": {:hex, :telemetry_poller, "1.0.0", "db91bb424e07f2bb6e73926fcafbfcbcb295f0193e0a00e825e589a0a47e8453", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b3a24eafd66c3f42da30fc3ca7dda1e9d546c12250a2d60d7b81d264fbec4f6e"},
	"tesla": {:hex, :tesla, "1.11.0", "81b2b10213dddb27105ec6102d9eb0cc93d7097a918a0b1594f2dfd1a4601190", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:exjsx, ">= 3.0.0", [hex: :exjsx, repo: "hexpm", optional: true]}, {:finch, "~> 0.13", [hex: :finch, repo: "hexpm", optional: true]}, {:fuse, "~> 2.4", [hex: :fuse, repo: "hexpm", optional: true]}, {:gun, ">= 1.0.0", [hex: :gun, repo: "hexpm", optional: true]}, {:hackney, "~> 1.6", [hex: :hackney, repo: "hexpm", optional: true]}, {:ibrowse, "4.4.2", [hex: :ibrowse, repo: "hexpm", optional: true]}, {:jason, ">= 1.0.0", [hex: :jason, repo: "hexpm", optional: true]}, {:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.0", [hex: :mint, repo: "hexpm", optional: true]}, {:msgpax, "~> 2.3", [hex: :msgpax, repo: "hexpm", optional: true]}, {:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "b83ab5d4c2d202e1ea2b7e17a49f788d49a699513d7c4f08f2aef2c281be69db"},
	"thousand_island": {:hex, :thousand_island, "1.3.5", "6022b6338f1635b3d32406ff98d68b843ba73b3aa95cfc27154223244f3a6ca5", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "2be6954916fdfe4756af3239fb6b6d75d0b8063b5df03ba76fd8a4c87849e180"},
	"timex": {:hex, :timex, "3.7.7", "3ed093cae596a410759104d878ad7b38e78b7c2151c6190340835515d4a46b8a", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "0ec4b09f25fe311321f9fc04144a7e3affe48eb29481d7a5583849b6c4dfa0a7"},
	"toml": {:hex, :toml, "0.7.0", "fbcd773caa937d0c7a02c301a1feea25612720ac3fa1ccb8bfd9d30d822911de", [:mix], [], "hexpm", "0690246a2478c1defd100b0c9b89b4ea280a22be9a7b313a8a058a2408a2fa70"},
	"trailing_format_plug": {:hex, :trailing_format_plug, "0.0.7", "64b877f912cf7273bed03379936df39894149e35137ac9509117e59866e10e45", [:mix], [{:plug, "> 0.12.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "bd4fde4c15f3e993a999e019d64347489b91b7a9096af68b2bdadd192afa693f"},
	"tzdata": {:hex, :tzdata, "1.0.5", "69f1ee029a49afa04ad77801febaf69385f3d3e3d1e4b56b9469025677b89a28", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "55519aa2a99e5d2095c1e61cc74c9be69688f8ab75c27da724eb8279ff402a5a"},
	"ueberauth": {:hex, :ueberauth, "0.10.7", "5a31cbe11e7ce5c7484d745dc9e1f11948e89662f8510d03c616de03df581ebd", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "0bccf73e2ffd6337971340832947ba232877aa8122dba4c95be9f729c8987377"},
	"unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
	"unsafe": {:hex, :unsafe, "1.0.2", "23c6be12f6c1605364801f4b47007c0c159497d0446ad378b5cf05f1855c0581", [:mix], [], "hexpm", "b485231683c3ab01a9cd44cb4a79f152c6f3bb87358439c6f68791b85c2df675"},
	"vix": {:hex, :vix, "0.26.0", "027f10b6969b759318be84bd0bd8c88af877445e4e41cf96a0460392cea5399c", [:make, :mix], [{:castore, "~> 1.0 or ~> 0.1", [hex: :castore, repo: "hexpm", optional: false]}, {:cc_precompiler, "~> 0.2 or ~> 0.1.4", [hex: :cc_precompiler, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.8 or ~> 0.7.3", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:kino, "~> 0.7", [hex: :kino, repo: "hexpm", optional: true]}], "hexpm", "71b0a79ae7f199cacfc8e679b0e4ba25ee47dc02e182c5b9097efb29fbe14efd"},
	"web_push_encryption": {:hex, :web_push_encryption, "0.3.1", "76d0e7375142dfee67391e7690e89f92578889cbcf2879377900b5620ee4708d", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.11.1", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "4f82b2e57622fb9337559058e8797cb0df7e7c9790793bdc4e40bc895f70e2a2"},
	"websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
	"websock_adapter": {:hex, :websock_adapter, "0.5.6", "0437fe56e093fd4ac422de33bf8fc89f7bc1416a3f2d732d8b2c8fd54792fe60", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "e04378d26b0af627817ae84c92083b7e97aca3121196679b73c73b99d0d133ea"},
	"websockex": {:hex, :websockex, "0.4.3", "92b7905769c79c6480c02daacaca2ddd49de936d912976a4d3c923723b647bf0", [:mix], [], "hexpm", "95f2e7072b85a3a4cc385602d42115b73ce0b74a9121d0d6dbbf557645ac53e4"},
	}
	diff --git a/rel/vm.args.eex b/rel/vm.args.eex
	index 71e803264..8e38fee4b 100644
	--- a/rel/vm.args.eex
	+++ b/rel/vm.args.eex
	@@ -1,11 +1,16 @@
	## Customize flags given to the VM: http://erlang.org/doc/man/erl.html
	## -mode/-name/-sname/-setcookie are configured via env vars, do not set them here

	## Number of dirty schedulers doing IO work (file, sockets, etc)
	##+SDio 5

	## Increase number of concurrent ports/sockets
	##+Q 65536

	## Tweak GC to run more often
	##-env ERL_FULLSWEEP_AFTER 10
	+
	+# Disable wasteful busywait.
	++sbwt none
	++sbwtdcpu none
	++sbwtdio none
	diff --git a/test/pleroma/object_test.exs b/test/pleroma/object_test.exs
	index 48d4d86eb..b3c528e32 100644
	--- a/test/pleroma/object_test.exs
	+++ b/test/pleroma/object_test.exs
	@@ -1,488 +1,344 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ObjectTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	- import ExUnit.CaptureLog
	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	- alias Pleroma.Activity
	alias Pleroma.Hashtag
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.Web.CommonAPI

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	ConfigMock \|> stub_with(Pleroma.Test.StaticConfig)
	:ok
	end

	test "returns an object by it's AP id" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object
	end

	describe "generic changeset" do
	test "it ensures uniqueness of the id" do
	object = insert(:note)
	cs = Object.change(%Object{}, %{data: %{id: object.data["id"]}})
	assert cs.valid?

	{:error, _result} = Repo.insert(cs)
	end
	end

	describe "deletion function" do
	test "deletes an object" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object

	Object.delete(found_object)

	found_object = Object.get_by_ap_id(object.data["id"])

	refute object == found_object

	assert found_object.data["type"] == "Tombstone"
	end

	test "ensures cache is cleared for the object" do
	object = insert(:note)
	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	assert object == cached_object

	Cachex.put(:web_resp_cache, URI.parse(object.data["id"]).path, "cofe")

	Object.delete(cached_object)

	{:ok, nil} = Cachex.get(:object_cache, "object:#{object.data["id"]}")
	{:ok, nil} = Cachex.get(:web_resp_cache, URI.parse(object.data["id"]).path)

	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	refute object == cached_object

	assert cached_object.data["type"] == "Tombstone"
	end
	end

	describe "delete attachments" do
	setup do: clear_config([Pleroma.Upload])
	setup do: clear_config([:instance, :cleanup_attachments])

	test "Disabled via config" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([:instance, :cleanup_attachments], false)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	refute Object.get_by_id(attachment.id) == nil

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")
	end

	test "in subdirectories" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([:instance, :cleanup_attachments], true)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end

	test "with dedupe enabled" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([Pleroma.Upload, :filters], [Pleroma.Upload.Filter.Dedupe])
	clear_config([:instance, :cleanup_attachments], true)

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	File.mkdir_p!(uploads_dir)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	filename = Path.basename(href)

	assert {:ok, files} = File.ls(uploads_dir)
	assert filename in files

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil
	assert {:ok, files} = File.ls(uploads_dir)
	refute filename in files
	end

	test "with objects that have legacy data.url attribute" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([:instance, :cleanup_attachments], true)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	{:ok, %Object{}} = Object.create(%{url: "https://google.com", actor: user.ap_id})

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end

	test "With custom base_url" do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	clear_config([Pleroma.Upload, :base_url], "https://sub.domain.tld/dir/")
	clear_config([:instance, :cleanup_attachments], true)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	user = insert(:user)

	{:ok, %Object{} = attachment} =
	Pleroma.Web.ActivityPub.ActivityPub.upload(file, actor: user.ap_id)

	%{data: %{"attachment" => [%{"url" => [%{"href" => href}]}]}} =
	note = insert(:note, %{user: user, data: %{"attachment" => [attachment.data]}})

	uploads_dir = Pleroma.Config.get!([Pleroma.Uploaders.Local, :uploads])

	path = href \|> Path.dirname() \|> Path.basename()

	assert {:ok, ["an_image.jpg"]} == File.ls("#{uploads_dir}/#{path}")

	Object.delete(note)

	ObanHelpers.perform(all_enqueued(worker: Pleroma.Workers.AttachmentsCleanupWorker))

	assert Object.get_by_id(note.id).data["deleted"]
	assert Object.get_by_id(attachment.id) == nil

	assert {:ok, []} == File.ls("#{uploads_dir}/#{path}")
	end
	end

	describe "normalizer" do
	@url "http://mastodon.example.org/@admin/99541947525187367"
	test "does not fetch unknown objects by default" do
	assert nil == Object.normalize(@url)
	end

	test "fetches unknown objects when fetch is explicitly true" do
	%Object{} = object = Object.normalize(@url, fetch: true)

	assert object.data["url"] == @url
	end

	test "does not fetch unknown objects when fetch is false" do
	assert is_nil(
	Object.normalize(@url,
	fetch: false
	)
	)
	end
	end

	- describe "get_by_id_and_maybe_refetch" do
	- setup do
	- mock(fn
	- %{method: :get, url: "https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d"} ->
	- %Tesla.Env{
	- status: 200,
	- body: File.read!("test/fixtures/tesla_mock/poll_original.json"),
	- headers: HttpRequestMock.activitypub_object_headers()
	- }
	-
	- env ->
	- apply(HttpRequestMock, :request, [env])
	- end)
	-
	- mock_modified = fn resp ->
	- mock(fn
	- %{method: :get, url: "https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d"} ->
	- resp
	-
	- env ->
	- apply(HttpRequestMock, :request, [env])
	- end)
	- end
	-
	- on_exit(fn -> mock(fn env -> apply(HttpRequestMock, :request, [env]) end) end)
	-
	- [mock_modified: mock_modified]
	- end
	-
	- test "refetches if the time since the last refetch is greater than the interval", %{
	- mock_modified: mock_modified
	- } do
	- %Object{} =
	- object =
	- Object.normalize("https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d",
	- fetch: true
	- )
	-
	- Object.set_cache(object)
	-
	- assert Enum.at(object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	- assert Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 0
	-
	- mock_modified.(%Tesla.Env{
	- status: 200,
	- body: File.read!("test/fixtures/tesla_mock/poll_modified.json"),
	- headers: HttpRequestMock.activitypub_object_headers()
	- })
	-
	- updated_object = Object.get_by_id_and_maybe_refetch(object.id, interval: -1)
	- object_in_cache = Object.get_cached_by_ap_id(object.data["id"])
	- assert updated_object == object_in_cache
	- assert Enum.at(updated_object.data["oneOf"], 0)["replies"]["totalItems"] == 8
	- assert Enum.at(updated_object.data["oneOf"], 1)["replies"]["totalItems"] == 3
	- end
	-
	- test "returns the old object if refetch fails", %{mock_modified: mock_modified} do
	- %Object{} =
	- object =
	- Object.normalize("https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d",
	- fetch: true
	- )
	-
	- Object.set_cache(object)
	-
	- assert Enum.at(object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	- assert Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 0
	-
	- assert capture_log(fn ->
	- mock_modified.(%Tesla.Env{status: 404, body: ""})
	-
	- updated_object = Object.get_by_id_and_maybe_refetch(object.id, interval: -1)
	- object_in_cache = Object.get_cached_by_ap_id(object.data["id"])
	- assert updated_object == object_in_cache
	- assert Enum.at(updated_object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	- assert Enum.at(updated_object.data["oneOf"], 1)["replies"]["totalItems"] == 0
	- end) =~
	- "[error] Couldn't refresh https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d"
	- end
	-
	- test "does not refetch if the time since the last refetch is greater than the interval", %{
	- mock_modified: mock_modified
	- } do
	- %Object{} =
	- object =
	- Object.normalize("https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d",
	- fetch: true
	- )
	-
	- Object.set_cache(object)
	-
	- assert Enum.at(object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	- assert Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 0
	-
	- mock_modified.(%Tesla.Env{
	- status: 200,
	- body: File.read!("test/fixtures/tesla_mock/poll_modified.json"),
	- headers: HttpRequestMock.activitypub_object_headers()
	- })
	-
	- updated_object = Object.get_by_id_and_maybe_refetch(object.id, interval: 100)
	- object_in_cache = Object.get_cached_by_ap_id(object.data["id"])
	- assert updated_object == object_in_cache
	- assert Enum.at(updated_object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	- assert Enum.at(updated_object.data["oneOf"], 1)["replies"]["totalItems"] == 0
	- end
	-
	- test "preserves internal fields on refetch", %{mock_modified: mock_modified} do
	- %Object{} =
	- object =
	- Object.normalize("https://patch.cx/objects/9a172665-2bc5-452d-8428-2361d4c33b1d",
	- fetch: true
	- )
	-
	- Object.set_cache(object)
	-
	- assert Enum.at(object.data["oneOf"], 0)["replies"]["totalItems"] == 4
	- assert Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 0
	-
	- user = insert(:user)
	- activity = Activity.get_create_by_object_ap_id(object.data["id"])
	- {:ok, activity} = CommonAPI.favorite(activity.id, user)
	- object = Object.get_by_ap_id(activity.data["object"])
	-
	- assert object.data["like_count"] == 1
	-
	- mock_modified.(%Tesla.Env{
	- status: 200,
	- body: File.read!("test/fixtures/tesla_mock/poll_modified.json"),
	- headers: HttpRequestMock.activitypub_object_headers()
	- })
	-
	- updated_object = Object.get_by_id_and_maybe_refetch(object.id, interval: -1)
	- object_in_cache = Object.get_cached_by_ap_id(object.data["id"])
	- assert updated_object == object_in_cache
	- assert Enum.at(updated_object.data["oneOf"], 0)["replies"]["totalItems"] == 8
	- assert Enum.at(updated_object.data["oneOf"], 1)["replies"]["totalItems"] == 3
	-
	- assert updated_object.data["like_count"] == 1
	- end
	- end
	-
	describe ":hashtags association" do
	test "Hashtag records are created with Object record and updated on its change" do
	user = insert(:user)

	{:ok, %{object: object}} =
	CommonAPI.post(user, %{status: "some text #hashtag1 #hashtag2 ..."})

	assert [%Hashtag{name: "hashtag1"}, %Hashtag{name: "hashtag2"}] =
	Enum.sort_by(object.hashtags, & &1.name)

	{:ok, object} = Object.update_data(object, %{"tag" => []})

	assert [] = object.hashtags

	object = Object.get_by_id(object.id) \|> Repo.preload(:hashtags)
	assert [] = object.hashtags

	{:ok, object} = Object.update_data(object, %{"tag" => ["abc", "def"]})

	assert [%Hashtag{name: "abc"}, %Hashtag{name: "def"}] =
	Enum.sort_by(object.hashtags, & &1.name)
	end
	end

	describe "get_emoji_reactions/1" do
	test "3-tuple current format" do
	object = %Object{
	data: %{
	"reactions" => [
	["x", ["https://some/user"], "https://some/emoji"]
	]
	}
	}

	assert Object.get_emoji_reactions(object) == object.data["reactions"]
	end

	test "2-tuple legacy format" do
	object = %Object{
	data: %{
	"reactions" => [
	["x", ["https://some/user"]]
	]
	}
	}

	assert Object.get_emoji_reactions(object) == [["x", ["https://some/user"], nil]]
	end

	test "Map format" do
	object = %Object{
	data: %{
	"reactions" => %{
	"x" => ["https://some/user"]
	}
	}
	}

	assert Object.get_emoji_reactions(object) == [["x", ["https://some/user"], nil]]
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	index 3bd589f49..d4175b56f 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_controller_test.exs
	@@ -1,2139 +1,2160 @@
	# 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.ActivityPubControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Delivery
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Endpoint
	alias Pleroma.Workers.ReceiverWorker

	import Pleroma.Factory

	require Pleroma.Constants

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
	:ok
	end

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	setup do: clear_config([:instance, :federating], true)

	describe "/relay" do
	setup do: clear_config([:instance, :allow_relay])

	test "with the relay active, it returns the relay user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(200)

	assert res["id"] =~ "/relay"
	end

	test "with the relay disabled, it returns 404", %{conn: conn} do
	clear_config([:instance, :allow_relay], false)

	conn
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :relay))
	\|> json_response(404)
	end
	end

	describe "/internal/fetch" do
	test "it returns the internal fetch user", %{conn: conn} do
	res =
	conn
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(200)

	assert res["id"] =~ "/fetch"
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get(activity_pub_path(conn, :internal_fetch))
	\|> json_response(404)
	end
	end

	describe "/users/:nickname" do
	test "it returns a json representation of the user with accept application/json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/activity+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns a json representation of the user with accept application/ld+json", %{
	conn: conn
	} do
	user = insert(:user)

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/users/#{user.nickname}")

	user = User.get_cached_by_id(user.id)

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
	end

	test "it returns 404 for remote users", %{
	conn: conn
	} do
	user = insert(:user, local: false, nickname: "remoteuser@example.com")

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/#{user.nickname}.json")

	assert json_response(conn, 404)
	end

	test "it returns error when user is not found", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/jimm")
	\|> json_response(404)

	assert response == "Not found"
	end
	end

	describe "mastodon compatibility routes" do
	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/raymoo/statuses/999999999")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: object})
	end

	test "it returns a json representation of the activity with accept application/json", %{
	conn: conn
	} do
	{:ok, object} =
	%{
	"type" => "Note",
	"content" => "hey",
	"id" => Endpoint.url() <> "/users/raymoo/statuses/999999999",
	"actor" => Endpoint.url() <> "/users/raymoo",
	"to" => [Pleroma.Constants.as_public()]
	}
	\|> Object.create()

	{:ok, activity, _} =
	%{
	"id" => object.data["id"] <> "/activity",
	"type" => "Create",
	"object" => object.data["id"],
	"actor" => object.data["actor"],
	"to" => object.data["to"]
	}
	\|> ActivityPub.persist(local: true)

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/users/raymoo/statuses/999999999/activity")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end
	end

	describe "/objects/:uuid" do
	test "it doesn't return a local-only object", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns local-only objects when authenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(response, 200) == ObjectView.render("object.json", %{object: object})
	end

	test "does not return local-only objects for remote users", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user, local: false)

	{:ok, post} =
	CommonAPI.post(user, %{status: "test @#{reader.nickname}", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	json_response(response, 404)
	end

	test "it returns a json representation of the object with accept application/json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/activity+json",
	%{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "it returns a json representation of the object with accept application/ld+json", %{
	conn: conn
	} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header(
	"accept",
	"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
	)
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
	end

	test "does not cache authenticated response", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user)

	{:ok, post} =
	CommonAPI.post(user, %{status: "test @#{reader.nickname}", visibility: "local"})

	object = Object.normalize(post, fetch: false)
	uuid = String.split(object.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	json_response(response, 200)

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(404)
	end

	test "it returns 404 for non-public messages", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns visible non-public messages when authenticated", %{conn: conn} do
	note = insert(:direct_note)
	uuid = String.split(note.data["id"], "/") \|> List.last()
	user = User.get_by_ap_id(note.data["actor"])
	marisa = insert(:user)

	assert conn
	\|> assign(:user, marisa)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(404)

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")
	\|> json_response(200)

	assert response == ObjectView.render("object.json", %{object: note})
	end

	test "it returns 404 for tombstone objects", %{conn: conn} do
	tombstone = insert(:tombstone)
	uuid = String.split(tombstone.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn, 404)
	end

	test "it caches a response", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after object deletion", %{conn: conn} do
	note = insert(:note)
	uuid = String.split(note.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Object.delete(note)

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/objects/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/activities/:uuid" do
	test "it doesn't return a local-only activity", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	uuid = String.split(post.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns local-only activities when authenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{status: "test", visibility: "local"})

	assert Pleroma.Web.ActivityPub.Visibility.local_public?(post)

	uuid = String.split(post.data["id"], "/") \|> List.last()

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(response, 200) == ObjectView.render("object.json", %{object: post})
	end

	test "it returns a json representation of the activity", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
	end

	test "it returns 404 for non-public activities", %{conn: conn} do
	activity = insert(:direct_note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn, 404)
	end

	test "returns visible non-public messages when authenticated", %{conn: conn} do
	note = insert(:direct_note_activity)
	uuid = String.split(note.data["id"], "/") \|> List.last()
	user = User.get_by_ap_id(note.data["actor"])
	marisa = insert(:user)

	assert conn
	\|> assign(:user, marisa)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")
	\|> json_response(404)

	assert response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")
	\|> json_response(200)

	assert response == ObjectView.render("object.json", %{object: note})
	end

	test "it caches a response", %{conn: conn} do
	activity = insert(:note_activity)
	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok) == json_response(conn2, :ok)
	assert Enum.any?(conn2.resp_headers, &(&1 == {"x-cache", "HIT from Pleroma"}))
	end

	test "cached purged after activity deletion", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "cofe"})

	uuid = String.split(activity.data["id"], "/") \|> List.last()

	conn1 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert json_response(conn1, :ok)
	assert Enum.any?(conn1.resp_headers, &(&1 == {"x-cache", "MISS from Pleroma"}))

	Activity.delete_all_by_object_ap_id(activity.object.data["id"])

	conn2 =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/activities/#{uuid}")

	assert "Not found" == json_response(conn2, :not_found)
	end
	end

	describe "/inbox" do
	test "it inserts an incoming activity into the database", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it inserts an incoming activity into the database" <>
	"even if we can't fetch the user but have it in our db",
	%{conn: conn} do
	user =
	insert(:user,
	ap_id: "https://mastodon.example.org/users/raymoo",
	local: false,
	last_refreshed_at: nil
	)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> put_in(["object", "attributedTo"], user.ap_id)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()

	sender_url = data["actor"]
	Instances.set_consistently_unreachable(sender_url)
	refute Instances.reachable?(sender_url)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_url)
	end

	test "accept follow activity", %{conn: conn} do
	clear_config([:instance, :federating], true)
	relay = Relay.get_actor()

	assert {:ok, %Activity{} = activity} = Relay.follow("https://relay.mastodon.host/actor")

	followed_relay = Pleroma.User.get_by_ap_id("https://relay.mastodon.host/actor")
	relay = refresh_record(relay)

	accept =
	File.read!("test/fixtures/relay/accept-follow.json")
	\|> String.replace("{{ap_id}}", relay.ap_id)
	\|> String.replace("{{activity_id}}", activity.data["id"])

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", accept)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.FollowingRelationship.following?(
	relay,
	followed_relay
	)

	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok = Mix.Tasks.Pleroma.Relay.run(["list"])
	assert_receive {:mix_shell, :info, ["https://relay.mastodon.host/actor"]}
	end

	test "without valid signature, " <>
	"it accepts Create activities and requires enabled federation",
	%{conn: conn} do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Jason.decode!()
	non_create_data = File.read!("test/fixtures/mastodon-announce.json") \|> Jason.decode!()

	conn = put_req_header(conn, "content-type", "application/activity+json")

	clear_config([:instance, :federating], false)

	conn
	\|> post("/inbox", data)
	\|> json_response(403)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(403)

	clear_config([:instance, :federating], true)

	ret_conn = post(conn, "/inbox", data)
	assert "ok" == json_response(ret_conn, 200)

	conn
	\|> post("/inbox", non_create_data)
	\|> json_response(400)
	end

	# When activity is delivered to the inbox and we cannot immediately verify signature
	# we capture all the params and process it later in the Oban job.
	# Once we begin processing it through Oban we risk fetching the actor to validate the
	# activity which just leads to inserting a new user to process a Delete not relevant to us.
	test "Activities of certain types from an unknown actor are discarded", %{conn: conn} do
	example_bad_types =
	Pleroma.Constants.activity_types() --
	Pleroma.Constants.allowed_activity_types_from_strangers()

	Enum.each(example_bad_types, fn bad_type ->
	params =
	%{
	"type" => bad_type,
	"actor" => "https://unknown.mastodon.instance/users/somebody"
	}
	\|> Jason.encode!()

	conn
	\|> assign(:valid_signature, false)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", params)
	\|> json_response(400)

	assert all_enqueued() == []
	end)
	end

	test "Unknown activity types are discarded", %{conn: conn} do
	unknown_types = ["Poke", "Read", "Dazzle"]

	Enum.each(unknown_types, fn bad_type ->
	params =
	%{
	"type" => bad_type,
	"actor" => "https://unknown.mastodon.instance/users/somebody"
	}
	\|> Jason.encode!()

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", params)
	\|> json_response(400)

	assert all_enqueued() == []
	end)
	end

	test "accepts Add/Remove activities", %{conn: conn} do
	object_id = "c61d6733-e256-4fe1-ab13-1e369789423f"

	status =
	File.read!("test/fixtures/statuses/note.json")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	user =
	File.read!("test/fixtures/users_mock/user.json")
	\|> String.replace("{{nickname}}", "lain")

	actor = "https://example.com/users/lain"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: status,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^actor
	} ->
	%Tesla.Env{
	status: 200,
	body: user,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{method: :get, url: "https://example.com/users/lain/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/users_mock/masto_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"id" => "https://example.com/objects/d61d6733-e256-4fe1-ab13-1e369789423f",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()]
	}

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	user = User.get_cached_by_ap_id(data["actor"])
	assert user.pinned_objects[data["object"]]

	data = %{
	"id" => "https://example.com/objects/d61d6733-e256-4fe1-ab13-1e369789423d",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Remove",
	"to" => [Pleroma.Constants.as_public()]
	}

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	user = refresh_record(user)
	refute user.pinned_objects[data["object"]]
	end

	test "mastodon pin/unpin", %{conn: conn} do
	status_id = "105786274556060421"

	status =
	File.read!("test/fixtures/statuses/masto-note.json")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{status_id}}", status_id)

	status_url = "https://example.com/users/lain/statuses/#{status_id}"

	user =
	File.read!("test/fixtures/users_mock/user.json")
	\|> String.replace("{{nickname}}", "lain")

	actor = "https://example.com/users/lain"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^status_url
	} ->
	%Tesla.Env{
	status: 200,
	body: status,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^actor
	} ->
	%Tesla.Env{
	status: 200,
	body: user,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{method: :get, url: "https://example.com/users/lain/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/users_mock/masto_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => actor,
	"object" => status_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Add"
	}

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_object_ap_id_with_object(data["object"])
	user = User.get_cached_by_ap_id(data["actor"])
	assert user.pinned_objects[data["object"]]

	data = %{
	"actor" => actor,
	"object" => status_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Remove"
	}

	assert "ok" ==
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_object_ap_id_with_object(data["object"])
	user = refresh_record(user)
	refute user.pinned_objects[data["object"]]
	end
	end

	describe "/users/:nickname/inbox" do
	setup do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Jason.decode!()

	[data: data]
	end

	test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("bcc", [user.ap_id])
	\|> Kernel.put_in(["object", "bcc"], [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects an invalid incoming activity", %{conn: conn, data: data} do
	user = insert(:user, is_active: false)

	data =
	data
	\|> Map.put("bcc", [user.ap_id])
	\|> Kernel.put_in(["object", "bcc"], [user.ap_id])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "Invalid request." == json_response(conn, 400)
	end

	test "it accepts messages with to as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", user.ap_id)
	\|> Map.put("cc", [])
	\|> Kernel.put_in(["object", "to"], user.ap_id)
	\|> Kernel.put_in(["object", "cc"], [])

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts messages with cc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", [])
	\|> Map.put("cc", user.ap_id)
	\|> Kernel.put_in(["object", "to"], [])
	\|> Kernel.put_in(["object", "cc"], user.ap_id)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert user.ap_id in activity.recipients
	end

	test "it accepts messages with bcc as string instead of array", %{conn: conn, data: data} do
	user = insert(:user)

	data =
	data
	\|> Map.put("to", [])
	\|> Map.put("cc", [])
	\|> Map.put("bcc", user.ap_id)
	\|> Kernel.put_in(["object", "to"], [])
	\|> Kernel.put_in(["object", "cc"], [])
	\|> Kernel.put_in(["object", "bcc"], user.ap_id)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it accepts announces with to as string instead of array", %{conn: conn} do
	user = insert(:user)

	{:ok, post} = CommonAPI.post(user, %{status: "hey"})
	announcer = insert(:user, local: false)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => announcer.ap_id,
	"id" => "#{announcer.ap_id}/statuses/19512778738411822/activity",
	"object" => post.data["object"],
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => [user.ap_id],
	"type" => "Announce"
	}

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	%Activity{} = activity = Activity.get_by_ap_id(data["id"])
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.recipients
	end

	test "it accepts messages from actors that are followed by the user", %{
	conn: conn,
	data: data
	} do
	recipient = insert(:user)
	actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})

	{:ok, recipient, actor} = User.follow(recipient, actor)

	object =
	data["object"]
	\|> Map.put("attributedTo", actor.ap_id)

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

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	assert Activity.get_by_ap_id(data["id"])
	end

	test "it rejects reads from other users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(conn, 403)
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:direct_note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/inbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
	user = insert(:user)
	data = Map.put(data, "bcc", [user.ap_id])

	sender_host = URI.parse(data["actor"]).host
	Instances.set_consistently_unreachable(sender_host)
	refute Instances.reachable?(sender_host)

	conn =
	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/inbox", data)

	assert "ok" == json_response(conn, 200)
	assert Instances.reachable?(sender_host)
	end

	test "it removes all follower collections but actor's", %{conn: conn} do
	[actor, recipient] = insert_pair(:user)

	to = [
	recipient.ap_id,
	recipient.follower_address,
	"https://www.w3.org/ns/activitystreams#Public"
	]

	cc = [recipient.follower_address, actor.follower_address]

	data = %{
	"@context" => ["https://www.w3.org/ns/activitystreams"],
	"type" => "Create",
	"id" => Utils.generate_activity_id(),
	"to" => to,
	"cc" => cc,
	"actor" => actor.ap_id,
	"object" => %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => "It's a note",
	"attributedTo" => actor.ap_id,
	"id" => Utils.generate_object_id()
	}
	}

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{recipient.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert activity = Activity.get_by_ap_id(data["id"])

	assert activity.id
	assert actor.follower_address in activity.recipients
	assert actor.follower_address in activity.data["cc"]

	refute recipient.follower_address in activity.recipients
	refute recipient.follower_address in activity.data["cc"]
	refute recipient.follower_address in activity.data["to"]
	end

	test "it requires authentication", %{conn: conn} do
	user = insert(:user)
	conn = put_req_header(conn, "accept", "application/activity+json")

	ret_conn = get(conn, "/users/#{user.nickname}/inbox")
	assert json_response(ret_conn, 403)

	ret_conn =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/inbox")

	assert json_response(ret_conn, 200)
	end

	test "forwarded report", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	actor = insert(:user, local: false)
	remote_domain = URI.parse(actor.ap_id).host
	reported_user = insert(:user)

	note = insert(:note_activity, user: reported_user)

	data = %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"https://#{remote_domain}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	],
	"actor" => actor.ap_id,
	"cc" => [
	reported_user.ap_id
	],
	"content" => "test",
	"context" => "context",
	"id" => "http://#{remote_domain}/activities/02be56cf-35e3-46b4-b2c6-47ae08dfee9e",
	"nickname" => reported_user.nickname,
	"object" => [
	reported_user.ap_id,
	%{
	"actor" => %{
	"actor_type" => "Person",
	"approval_pending" => false,
	"avatar" => "",
	"confirmation_pending" => false,
	"deactivated" => false,
	"display_name" => "test user",
	"id" => reported_user.id,
	"local" => false,
	"nickname" => reported_user.nickname,
	"registration_reason" => nil,
	"roles" => %{
	"admin" => false,
	"moderator" => false
	},
	"tags" => [],
	"url" => reported_user.ap_id
	},
	"content" => "",
	"id" => note.data["id"],
	"published" => note.data["published"],
	"type" => "Note"
	}
	],
	"published" => note.data["published"],
	"state" => "open",
	"to" => [],
	"type" => "Flag"
	}

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reported_user.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	assert Pleroma.Repo.aggregate(Activity, :count, :id) == 2

	ObanHelpers.perform_all()

	Swoosh.TestAssertions.assert_email_sent(
	to: {admin.name, admin.email},
	html_body: ~r/Reported Account:/i
	)
	end

	test "forwarded report from mastodon", %{conn: conn} do
	admin = insert(:user, is_admin: true)
	actor = insert(:user, local: false)
	remote_domain = URI.parse(actor.ap_id).host
	remote_actor = "https://#{remote_domain}/actor"
	[reported_user, another] = insert_list(2, :user)

	note = insert(:note_activity, user: reported_user)

	Pleroma.Web.CommonAPI.favorite(note.id, another)

	mock_json_body =
	"test/fixtures/mastodon/application_actor.json"
	\|> File.read!()
	\|> String.replace("{{DOMAIN}}", remote_domain)

	Tesla.Mock.mock(fn %{url: ^remote_actor} ->
	%Tesla.Env{
	status: 200,
	body: mock_json_body,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"actor" => remote_actor,
	"content" => "test report",
	"id" => "https://#{remote_domain}/e3b12fd1-948c-446e-b93b-a5e67edbe1d8",
	"object" => [
	reported_user.ap_id,
	note.data["object"]
	],
	"type" => "Flag"
	}

	conn
	\|> assign(:valid_signature, true)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reported_user.nickname}/inbox", data)
	\|> json_response(200)

	ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))

	flag_activity = "Flag" \|> Pleroma.Activity.Queries.by_type() \|> Pleroma.Repo.one()
	reported_user_ap_id = reported_user.ap_id

	[^reported_user_ap_id, flag_data] = flag_activity.data["object"]

	Enum.each(~w(actor content id published type), &Map.has_key?(flag_data, &1))
	ObanHelpers.perform_all()

	Swoosh.TestAssertions.assert_email_sent(
	to: {admin.name, admin.email},
	html_body: ~r/#{note.data["object"]}/i
	)
	end
	+
	+ test "it accepts an incoming Block", %{conn: conn, data: data} do
	+ user = insert(:user)
	+
	+ data =
	+ data
	+ \|> Map.put("type", "Block")
	+ \|> Map.put("to", [user.ap_id])
	+ \|> Map.put("cc", [])
	+ \|> Map.put("object", user.ap_id)
	+
	+ conn =
	+ conn
	+ \|> assign(:valid_signature, true)
	+ \|> put_req_header("content-type", "application/activity+json")
	+ \|> post("/users/#{user.nickname}/inbox", data)
	+
	+ assert "ok" == json_response(conn, 200)
	+ ObanHelpers.perform(all_enqueued(worker: ReceiverWorker))
	+ assert Activity.get_by_ap_id(data["id"])
	+ end
	end

	describe "GET /users/:nickname/outbox" do
	test "it paginates correctly", %{conn: conn} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	outbox_endpoint = user.ap_id <> "/outbox"

	_posts =
	for i <- 0..25 do
	{:ok, activity} = CommonAPI.post(user, %{status: "post #{i}"})
	activity
	end

	result =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint <> "?page=true")
	\|> json_response(200)

	result_ids = Enum.map(result["orderedItems"], fn x -> x["id"] end)
	assert length(result["orderedItems"]) == 20
	assert length(result_ids) == 20
	assert result["next"]
	assert String.starts_with?(result["next"], outbox_endpoint)

	result_next =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(result["next"])
	\|> json_response(200)

	result_next_ids = Enum.map(result_next["orderedItems"], fn x -> x["id"] end)
	assert length(result_next["orderedItems"]) == 6
	assert length(result_next_ids) == 6
	refute Enum.find(result_next_ids, fn x -> x in result_ids end)
	refute Enum.find(result_ids, fn x -> x in result_next_ids end)
	assert String.starts_with?(result["id"], outbox_endpoint)

	result_next_again =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(result_next["id"])
	\|> json_response(200)

	assert result_next == result_next_again
	end

	test "it returns 200 even if there're no activities", %{conn: conn} do
	user = insert(:user)
	outbox_endpoint = user.ap_id <> "/outbox"

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(outbox_endpoint)

	result = json_response(conn, 200)
	assert outbox_endpoint == result["id"]
	end

	test "it returns a local note activity when authenticated as local user", %{conn: conn} do
	user = insert(:user)
	reader = insert(:user)
	{:ok, note_activity} = CommonAPI.post(user, %{status: "mew mew", visibility: "local"})
	ap_id = note_activity.data["id"]

	resp =
	conn
	\|> assign(:user, reader)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")
	\|> json_response(200)

	assert %{"orderedItems" => [%{"id" => ^ap_id}]} = resp
	end

	test "it does not return a local note activity when unauthenticated", %{conn: conn} do
	user = insert(:user)
	{:ok, _note_activity} = CommonAPI.post(user, %{status: "mew mew", visibility: "local"})

	resp =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")
	\|> json_response(200)

	assert %{"orderedItems" => []} = resp
	end

	test "it returns a note activity in a collection", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ note_object.data["content"]
	end

	test "it returns an announce activity in a collection", %{conn: conn} do
	announce_activity = insert(:announce_activity)
	user = User.get_cached_by_ap_id(announce_activity.data["actor"])

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("accept", "application/activity+json")
	\|> get("/users/#{user.nickname}/outbox?page=true")

	assert response(conn, 200) =~ announce_activity.data["object"]
	end

	test "It returns poll Answers when authenticated", %{conn: conn} do
	poller = insert(:user)
	voter = insert(:user)

	{:ok, activity} =
	CommonAPI.post(poller, %{
	status: "suya...",
	poll: %{options: ["suya", "suya.", "suya.."], expires_in: 10}
	})

	assert question = Object.normalize(activity, fetch: false)

	{:ok, [activity], _object} = CommonAPI.vote(question, voter, [1])

	assert outbox_get =
	conn
	\|> assign(:user, voter)
	\|> put_req_header("accept", "application/activity+json")
	\|> get(voter.ap_id <> "/outbox?page=true")
	\|> json_response(200)

	assert [answer_outbox] = outbox_get["orderedItems"]
	assert answer_outbox["id"] == activity.data["id"]
	end
	end

	describe "POST /users/:nickname/outbox (C2S)" do
	setup do: clear_config([:instance, :limit])

	setup do
	[
	activity: %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "AP C2S test",
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}
	}
	]
	end

	test "it rejects posts from other users / unauthenticated users", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	other_user = insert(:user)
	conn = put_req_header(conn, "content-type", "application/activity+json")

	conn
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)

	conn
	\|> assign(:user, other_user)
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(403)
	end

	test "it inserts an incoming create activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(result["id"])
	assert result["object"]
	assert %Object{data: object} = Object.normalize(result["object"], fetch: false)
	assert object["content"] == activity["object"]["content"]
	end

	test "it rejects anything beyond 'Note' creations", %{conn: conn, activity: activity} do
	user = insert(:user)

	activity =
	activity
	\|> put_in(["object", "type"], "Benis")

	_result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)
	end

	test "it inserts an incoming sensitive activity into the database", %{
	conn: conn,
	activity: activity
	} do
	user = insert(:user)
	conn = assign(conn, :user, user)
	object = Map.put(activity["object"], "sensitive", true)
	activity = Map.put(activity, "object", object)

	response =
	conn
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(201)

	assert Activity.get_by_ap_id(response["id"])
	assert response["object"]
	assert %Object{data: response_object} = Object.normalize(response["object"], fetch: false)
	assert response_object["sensitive"] == true
	assert response_object["content"] == activity["object"]["content"]

	representation =
	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> get(response["id"])
	\|> json_response(200)

	assert representation["object"]["sensitive"] == true
	end

	test "it rejects an incoming activity with bogus type", %{conn: conn, activity: activity} do
	user = insert(:user)
	activity = Map.put(activity, "type", "BadType")

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)

	assert json_response(conn, 400)
	end

	test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	"type" => "Delete",
	"object" => %{
	"id" => note_object.data["id"]
	}
	}

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)
	\|> json_response(201)

	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["type"] == "Tombstone"
	end

	test "it rejects delete activity of object from other actor", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = insert(:user)

	data = %{
	type: "Delete",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	assert json_response(conn, 403)
	end

	test "it increases like count when receiving a like action", %{conn: conn} do
	note_activity = insert(:note_activity)
	note_object = Object.normalize(note_activity, fetch: false)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	data = %{
	type: "Like",
	object: %{
	id: note_object.data["id"]
	}
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", data)

	result = json_response(conn, 201)
	assert Activity.get_by_ap_id(result["id"])

	assert object = Object.get_by_ap_id(note_object.data["id"])
	assert object.data["like_count"] == 1
	end

	test "it doesn't spreads faulty attributedTo or actor fields", %{
	conn: conn,
	activity: activity
	} do
	reimu = insert(:user, nickname: "reimu")
	cirno = insert(:user, nickname: "cirno")

	assert reimu.ap_id
	assert cirno.ap_id

	activity =
	activity
	\|> put_in(["object", "actor"], reimu.ap_id)
	\|> put_in(["object", "attributedTo"], reimu.ap_id)
	\|> put_in(["actor"], reimu.ap_id)
	\|> put_in(["attributedTo"], reimu.ap_id)

	_reimu_outbox =
	conn
	\|> assign(:user, cirno)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{reimu.nickname}/outbox", activity)
	\|> json_response(403)

	cirno_outbox =
	conn
	\|> assign(:user, cirno)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{cirno.nickname}/outbox", activity)
	\|> json_response(201)

	assert cirno_outbox["attributedTo"] == nil
	assert cirno_outbox["actor"] == cirno.ap_id

	assert cirno_object = Object.normalize(cirno_outbox["object"], fetch: false)
	assert cirno_object.data["actor"] == cirno.ap_id
	assert cirno_object.data["attributedTo"] == cirno.ap_id
	end

	test "Character limitation", %{conn: conn, activity: activity} do
	clear_config([:instance, :limit], 5)
	user = insert(:user)

	result =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/activity+json")
	\|> post("/users/#{user.nickname}/outbox", activity)
	\|> json_response(400)

	assert result == "Character limit (5 characters) exceeded, contains 11 characters"
	end
	end

	describe "/relay/followers" do
	test "it returns relay followers", %{conn: conn} do
	relay_actor = Relay.get_actor()
	user = insert(:user)
	User.follow(user, relay_actor)

	result =
	conn
	\|> get("/relay/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/followers")
	\|> json_response(404)
	end
	end

	describe "/relay/following" do
	test "it returns relay following", %{conn: conn} do
	result =
	conn
	\|> get("/relay/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == []
	end

	test "on non-federating instance, it returns 404", %{conn: conn} do
	clear_config([:instance, :federating], false)
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> get("/relay/following")
	\|> json_response(404)
	end
	end

	describe "/users/:nickname/followers" do
	test "it returns the followers in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user_two)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user.ap_id]
	end

	test "it returns a uri if the user has 'hide_followers' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_followers: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/followers")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_followers' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, hide_followers: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{other_user.nickname}/followers?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_followers' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_followers: true)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	other_user = insert(:user)
	User.follow(other_user, user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/followers?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/followers")
	\|> json_response(200)
	end
	end

	describe "/users/:nickname/following" do
	test "it returns the following in a collection", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert result["first"]["orderedItems"] == [user_two.ap_id]
	end

	test "it returns a uri if the user has 'hide_follows' set", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)
	User.follow(user, user_two)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following")
	\|> json_response(200)

	assert is_binary(result["first"])
	end

	test "it returns a 403 error on pages, if the user has 'hide_follows' set and the request is from another user",
	%{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, hide_follows: true)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user_two.nickname}/following?page=1")

	assert result.status == 403
	assert result.resp_body == ""
	end

	test "it renders the page, if the user has 'hide_follows' set and the request is authenticated with the same user",
	%{conn: conn} do
	user = insert(:user, hide_follows: true)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=1")
	\|> json_response(200)

	assert result["totalItems"] == 1
	assert result["orderedItems"] == [other_user.ap_id]
	end

	test "it works for more than 10 users", %{conn: conn} do
	user = insert(:user)

	Enum.each(1..15, fn _ ->
	user = User.get_cached_by_id(user.id)
	other_user = insert(:user)
	User.follow(user, other_user)
	end)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)

	assert length(result["first"]["orderedItems"]) == 10
	assert result["first"]["totalItems"] == 15
	assert result["totalItems"] == 15

	result =
	conn
	\|> assign(:user, user)
	\|> get("/users/#{user.nickname}/following?page=2")
	\|> json_response(200)

	assert length(result["orderedItems"]) == 5
	assert result["totalItems"] == 15
	end

	test "does not require authentication", %{conn: conn} do
	user = insert(:user)

	conn
	\|> get("/users/#{user.nickname}/following")
	\|> json_response(200)
	end
	end

	describe "delivery tracking" do
	test "it tracks a signed object fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed activity fetch", %{conn: conn} do
	user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	end

	test "it tracks a signed object fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	object_path = String.trim_leading(object.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(object_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(object_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end

	test "it tracks a signed activity fetch when the json is cached", %{conn: conn} do
	user = insert(:user, local: false)
	other_user = insert(:user, local: false)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	activity_path = String.trim_leading(activity.data["id"], Pleroma.Web.Endpoint.url())

	conn
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, user)
	\|> get(activity_path)
	\|> json_response(200)

	build_conn()
	\|> put_req_header("accept", "application/activity+json")
	\|> assign(:user, other_user)
	\|> get(activity_path)
	\|> json_response(200)

	assert Delivery.get(object.id, user.id)
	assert Delivery.get(object.id, other_user.id)
	end
	end

	describe "Additional ActivityPub C2S endpoints" do
	test "GET /api/ap/whoami", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/ap/whoami")

	user = User.get_cached_by_id(user.id)

	assert UserView.render("user.json", %{user: user}) == json_response(conn, 200)

	conn
	\|> get("/api/ap/whoami")
	\|> json_response(403)
	end

	setup do: clear_config([:media_proxy])
	setup do: clear_config([Pleroma.Upload])

	test "POST /api/ap/upload_media", %{conn: conn} do
	user = insert(:user)

	desc = "Description of the image"

	image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	object =
	conn
	\|> assign(:user, user)
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(:created)

	assert object["name"] == desc
	assert object["type"] == "Document"
	assert object["actor"] == user.ap_id
	assert [%{"href" => object_href, "mediaType" => object_mediatype}] = object["url"]
	assert is_binary(object_href)
	assert object_mediatype == "image/jpeg"
	assert String.ends_with?(object_href, ".jpg")

	activity_request = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"object" => %{
	"type" => "Note",
	"content" => "AP C2S test, attachment",
	"attachment" => [object],
	"to" => "https://www.w3.org/ns/activitystreams#Public",
	"cc" => []
	}
	}

	activity_response =
	conn
	\|> assign(:user, user)
	\|> post("/users/#{user.nickname}/outbox", activity_request)
	\|> json_response(:created)

	assert activity_response["id"]
	assert activity_response["object"]
	assert activity_response["actor"] == user.ap_id

	assert %Object{data: %{"attachment" => [attachment]}} =
	Object.normalize(activity_response["object"], fetch: false)

	assert attachment["type"] == "Document"
	assert attachment["name"] == desc

	assert [
	%{
	"href" => ^object_href,
	"type" => "Link",
	"mediaType" => ^object_mediatype
	}
	] = attachment["url"]

	# Fails if unauthenticated
	conn
	\|> post("/api/ap/upload_media", %{"file" => image, "description" => desc})
	\|> json_response(403)
	end
	end

	test "pinned collection", %{conn: conn} do
	clear_config([:instance, :max_pinned_statuses], 2)
	user = insert(:user)
	objects = insert_list(2, :note, user: user)

	Enum.reduce(objects, user, fn %{data: %{"id" => object_id}}, user ->
	{:ok, updated} = User.add_pinned_object_id(user, object_id)
	updated
	end)

	%{nickname: nickname, featured_address: featured_address, pinned_objects: pinned_objects} =
	refresh_record(user)

	%{"id" => ^featured_address, "orderedItems" => items, "totalItems" => 2} =
	conn
	\|> get("/users/#{nickname}/collections/featured")
	\|> json_response(200)

	object_ids = Enum.map(items, & &1["id"])

	assert Enum.all?(pinned_objects, fn {obj_id, _} ->
	obj_id in object_ids
	end)
	end
	end
	diff --git a/test/pleroma/web/activity_pub/activity_pub_test.exs b/test/pleroma/web/activity_pub/activity_pub_test.exs
	index b4f6fb68a..72222ae88 100644
	--- a/test/pleroma/web/activity_pub/activity_pub_test.exs
	+++ b/test/pleroma/web/activity_pub/activity_pub_test.exs
	@@ -1,2715 +1,2746 @@
	# 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.ActivityPubTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import ExUnit.CaptureLog
	import Mock
	import Mox
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)

	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	:ok
	end

	setup do: clear_config([:instance, :federating])

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

	assert called(Pleroma.Web.Streamer.stream("participation", participations))
	end
	end

	test "streams them out on activity creation" do
	user_one = insert(:user)
	user_two = insert(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	{:ok, activity} =
	CommonAPI.post(user_one, %{
	status: "@#{user_two.nickname}",
	visibility: "direct"
	})

	conversation =
	activity.data["context"]
	\|> Pleroma.Conversation.get_for_ap_id()
	\|> Repo.preload(participations: :user)

	assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
	end
	end
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities = ActivityPub.fetch_activities([], %{visibility: "direct", actor_id: user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "unlisted", actor_id: user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{visibility: "private", actor_id: user.ap_id})

	assert activities == [private_activity]

	activities = ActivityPub.fetch_activities([], %{visibility: "public", actor_id: user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	visibility: ~w[private public],
	actor_id: user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "fetching excluded by visibility" do
	test "it excludes by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{status: ".", visibility: "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{status: ".", visibility: "direct"})

	{:ok, unlisted_activity} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(user, %{status: ".", visibility: "private"})

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "direct",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	refute direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "unlisted",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	refute unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "private",
	actor_id: user.ap_id
	})

	assert public_activity in activities
	assert unlisted_activity in activities
	refute private_activity in activities
	assert direct_activity in activities

	activities =
	ActivityPub.fetch_activities([], %{
	exclude_visibilities: "public",
	actor_id: user.ap_id
	})

	refute public_activity in activities
	assert unlisted_activity in activities
	assert private_activity in activities
	assert direct_activity in activities
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it returns a user that is invisible" do
	user_id = "http://mastodon.example.org/users/relay"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert User.invisible?(user)
	end

	test "it returns a user that accepts chat messages" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.accepts_chat_messages
	end

	test "works for guppe actors" do
	user_id = "https://gup.pe/u/bernie2020"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/guppe-actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.name == "Bernie2020 group"
	assert user.actor_type == "Group"
	end

	test "works for bridgy actors" do
	user_id = "https://fed.brid.gy/jk.nipponalba.scot"

	Tesla.Mock.mock(fn
	%{method: :get, url: ^user_id} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/bridgy/actor.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.actor_type == "Person"

	assert user.avatar == %{
	"type" => "Image",
	- "url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}]
	+ "url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}],
	+ "name" => "profile picture"
	}

	assert user.banner == %{
	"type" => "Image",
	- "url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}]
	+ "url" => [%{"href" => "https://jk.nipponalba.scot/images/profile.jpg"}],
	+ "name" => "profile picture"
	}
	end

	test "fetches user featured collection" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	object_data =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{object_id}}", object_id)
	\|> String.replace("{{nickname}}", "lain")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^ap_id
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^featured_url
	} ->
	%Tesla.Env{
	status: 200,
	body: featured_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	# wait for oban
	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user featured collection without embedded object" do
	ap_id = "https://example.com/users/lain"

	featured_url = "https://example.com/users/lain/collections/featured"

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> Jason.decode!()
	\|> Map.put("featured", featured_url)
	\|> Jason.encode!()

	object_id = Ecto.UUID.generate()

	featured_data =
	"test/fixtures/mastodon/collections/external_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	object_data =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{object_id}}", object_id)
	\|> String.replace("{{nickname}}", "lain")

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^ap_id
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^featured_url
	} ->
	%Tesla.Env{
	status: 200,
	body: featured_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object_data,
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(ap_id)

	assert_enqueued(
	worker: Pleroma.Workers.RemoteFetcherWorker,
	args: %{
	"op" => "fetch_remote",
	"id" => object_url,
	"depth" => 1
	}
	)

	# wait for oban
	Pleroma.Tests.ObanHelpers.perform_all()

	assert user.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	in_db = Pleroma.User.get_by_ap_id(ap_id)
	assert in_db.featured_address == featured_url
	assert Map.has_key?(user.pinned_objects, object_url)

	assert %{data: %{"id" => ^object_url}} = Object.get_by_ap_id(object_url)
	end

	test "fetches user birthday information from misskey" do
	user_id = "https://misskey.io/@mkljczk"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^user_id
	} ->
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/birthdays/misskey-user.json"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)

	assert user.birthday == ~D[2001-02-12]
	end
	+
	+ test "fetches avatar description" do
	+ user_id = "https://example.com/users/marcin"
	+
	+ user_data =
	+ "test/fixtures/users_mock/user.json"
	+ \|> File.read!()
	+ \|> String.replace("{{nickname}}", "marcin")
	+ \|> Jason.decode!()
	+ \|> Map.delete("featured")
	+ \|> Map.update("icon", %{}, fn image -> Map.put(image, "name", "image description") end)
	+ \|> Jason.encode!()
	+
	+ Tesla.Mock.mock(fn
	+ %{
	+ method: :get,
	+ url: ^user_id
	+ } ->
	+ %Tesla.Env{
	+ status: 200,
	+ body: user_data,
	+ headers: [{"content-type", "application/activity+json"}]
	+ }
	+ end)
	+
	+ {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	+
	+ assert user.avatar["name"] == "image description"
	+ end
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{status: ". #TEST"})
	{:ok, status_two} = CommonAPI.post(user, %{status: ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{status: ". #test #Reject"})

	{:ok, status_four} = CommonAPI.post(user, %{status: ". #Any1 #any2"})
	{:ok, status_five} = CommonAPI.post(user, %{status: ". #Any2 #any1"})

	for hashtag_timeline_strategy <- [:enabled, :disabled] do
	clear_config([:features, :improved_hashtag_timeline], hashtag_timeline_strategy)

	fetch_one = ActivityPub.fetch_activities([], %{type: "Create", tag: "test"})

	fetch_two = ActivityPub.fetch_activities([], %{type: "Create", tag: ["TEST", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test", "Essais"],
	tag_reject: ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["test"],
	tag_all: ["test", "REJECT"]
	})

	# Testing that deduplication (if needed) is done on DB (not Ecto) level; :limit is important
	fetch_five =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["ANY1", "any2"],
	limit: 2
	})

	fetch_six =
	ActivityPub.fetch_activities([], %{
	type: "Create",
	tag: ["any1", "Any2"],
	tag_all: [],
	tag_reject: []
	})

	# Regression test: passing empty lists as filter options shouldn't affect the results
	assert fetch_five == fetch_six

	[fetch_one, fetch_two, fetch_three, fetch_four, fetch_five] =
	Enum.map([fetch_one, fetch_two, fetch_three, fetch_four, fetch_five], fn statuses ->
	Enum.map(statuses, fn s -> Repo.preload(s, object: :hashtags) end)
	end)

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	assert fetch_five == [status_four, status_five]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, :remote_limit} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity, fetch: false)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert object = Object.normalize(activity, fetch: false)
	assert is_binary(object.data["id"])
	end
	end

	describe "listen activities" do
	test "does not increase user note count" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.listen(%{
	to: ["https://www.w3.org/ns/activitystreams#Public"],
	actor: user,
	context: "",
	object: %{
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"artist" => "lain",
	"title" => "lain radio episode 1",
	"length" => 180_000,
	"type" => "Audio"
	}
	})

	assert activity.actor == user.ap_id

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 0
	end

	test "can be fetched into a timeline" do
	_listen_activity_1 = insert(:listen)
	_listen_activity_2 = insert(:listen)
	_listen_activity_3 = insert(:listen)

	timeline = ActivityPub.fetch_activities([], %{type: ["Listen"]})

	assert length(timeline) == 3
	end
	end

	describe "create activities" do
	setup do
	[user: insert(:user)]
	end

	test "it reverts create", %{user: user} do
	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "creates activity if expiration is not configured and expires_at is not passed", %{
	user: user
	} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:ok, _} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})
	end

	test "rejects activity if expires_at present but expiration is not configured", %{user: user} do
	clear_config([Pleroma.Workers.PurgeExpiredActivity, :enabled], false)

	assert {:error, :expired_activities_disabled} =
	ActivityPub.create(%{
	to: ["user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	},
	additional: %{
	"expires_at" => DateTime.utc_now()
	}
	})

	assert Repo.aggregate(Activity, :count, :id) == 0
	assert Repo.aggregate(Object, :count, :id) == 0
	end

	test "removes doubled 'to' recipients", %{user: user} do
	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities", %{user: user} do
	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "1",
	visibility: "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "2",
	visibility: "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	status: "3",
	visibility: "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.note_count == 2
	end

	test "increases replies count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	reply_data = %{status: "1", in_reply_to_status_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end

	test "increates quotes count", %{user: user} do
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "1", visibility: "public"})
	ap_id = activity.data["id"]
	quote_data = %{status: "1", quote_id: activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "public"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "unlisted"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "private"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(quote_data, :visibility, "direct"))
	assert %{data: _data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["quotesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{blocking_user: user})
	assert activities == [activity_two, activity]
	end

	test "doesn't return activities with filtered words" do
	user = insert(:user)
	user_two = insert(:user)
	insert(:filter, user: user, phrase: "test", hide: true)

	{:ok, %{id: id1, data: %{"context" => context}}} = CommonAPI.post(user, %{status: "1"})

	{:ok, %{id: id2}} = CommonAPI.post(user_two, %{status: "2", in_reply_to_status_id: id1})

	{:ok, %{id: id3} = user_activity} =
	CommonAPI.post(user, %{status: "3 test?", in_reply_to_status_id: id2})

	{:ok, %{id: id4} = filtered_activity} =
	CommonAPI.post(user_two, %{status: "4 test!", in_reply_to_status_id: id3})

	{:ok, _} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})

	activities =
	context
	\|> ActivityPub.fetch_activities_for_context(%{user: user})
	\|> Enum.map(& &1.id)

	assert length(activities) == 4
	assert user_activity.id in activities
	refute filtered_activity.id in activities
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{blocking_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return activities from deactivated users" do
	_user = insert(:user)
	deactivated = insert(:user)
	active = insert(:user)
	{:ok, activity_one} = CommonAPI.post(deactivated, %{status: "hey!"})
	{:ok, activity_two} = CommonAPI.post(active, %{status: "yay!"})
	{:ok, _updated_user} = User.set_activation(deactivated, false)

	activities = ActivityPub.fetch_activities([], %{})

	refute Enum.member?(activities, activity_one)
	assert Enum.member?(activities, activity_two)
	end

	test "always see your own posts even when they address people you block" do
	user = insert(:user)
	blockee = insert(:user)

	{:ok, _} = User.block(user, blockee)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{blockee.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities with blocked users in 'to'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	{:ok, activity_three} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return announce activities with blocked users in 'cc'" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, _user_relationship} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{status: "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})

	assert object = Pleroma.Object.normalize(activity_two, fetch: false)

	data = %{
	"actor" => friend.ap_id,
	"object" => object.data["id"],
	"context" => object.data["context"],
	"type" => "Announce",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [blockee.ap_id]
	}

	assert {:ok, activity_three} = ActivityPub.insert(data)

	activities =
	ActivityPub.fetch_activities([], %{blocking_user: blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute activity in activities

	followed_user = insert(:user)
	CommonAPI.follow(followed_user, user)
	{:ok, repeat_activity} = CommonAPI.repeat(activity.id, followed_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: user, skip_preload: true})

	refute repeat_activity in activities
	end

	test "see your own posts even when they address actors from blocked domains" do
	user = insert(:user)

	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})

	{:ok, user} = User.block_domain(user, domain)

	{:ok, activity} = CommonAPI.post(user, %{status: "hey! @#{domain_user.nickname}"})

	activities = ActivityPub.fetch_activities([], %{blocking_user: user})

	assert Enum.member?(activities, activity)
	end

	test "does return activities from followed users on blocked domains" do
	domain = "meanies.social"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	blocker = insert(:user)

	{:ok, blocker, domain_user} = User.follow(blocker, domain_user)
	{:ok, blocker} = User.block_domain(blocker, domain)

	assert User.following?(blocker, domain_user)
	assert User.blocks_domain?(blocker, domain_user)
	refute User.blocks?(blocker, domain_user)

	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	assert activity in activities

	# And check that if the guy we DO follow boosts someone else from their domain,
	# that should be hidden
	another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
	bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
	bad_activity = insert(:note_activity, %{note: bad_note})
	{:ok, repeat_activity} = CommonAPI.repeat(bad_activity.id, domain_user)

	activities = ActivityPub.fetch_activities([], %{blocking_user: blocker, skip_preload: true})

	refute repeat_activity in activities
	end

	test "returns your own posts regardless of mute" do
	user = insert(:user)
	muted = insert(:user)

	{:ok, muted_post} = CommonAPI.post(muted, %{status: "Im stupid"})

	{:ok, reply} =
	CommonAPI.post(user, %{status: "I'm muting you", in_reply_to_status_id: muted_post.id})

	{:ok, _} = User.mute(user, muted)

	[activity] = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert activity.id == reply.id
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	muting_user: user,
	with_muted: true,
	skip_preload: true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, _user_mute} = User.unmute(user, activity_one_actor)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
	{:ok, _user_relationships} = User.mute(user, activity_three_actor)
	{:ok, %{data: %{"object" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities = ActivityPub.fetch_activities([], %{muting_user: user, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{muting_user: nil, skip_preload: true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return thread muted activities" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(activity_two, user)

	assert [_activity_one] = ActivityPub.fetch_activities([], %{muting_user: user})
	end

	test "returns thread muted activities when with_muted is set" do
	user = insert(:user)
	_activity_one = insert(:note_activity)
	note_two = insert(:note, data: %{"context" => "suya.."})
	activity_two = insert(:note_activity, note: note_two)

	{:ok, _activity_two} = CommonAPI.add_mute(activity_two, user)

	assert [_activity_two, _activity_one] =
	ActivityPub.fetch_activities([], %{muting_user: user, with_muted: true})
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	{:ok, user, booster} = User.follow(user, booster)

	{:ok, announce} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| User.following(user)])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{exclude_reblogs: true})

	assert activity == expected_activity
	end

	describe "irreversible filters" do
	setup do
	user = insert(:user)
	user_two = insert(:user)

	insert(:filter, user: user_two, phrase: "cofe", hide: true)
	insert(:filter, user: user_two, phrase: "ok boomer", hide: true)
	insert(:filter, user: user_two, phrase: "test", hide: false)

	params = %{
	type: ["Create", "Announce"],
	user: user_two
	}

	{:ok, %{user: user, user_two: user_two, params: params}}
	end

	test "it returns statuses if they don't contain exact filter words", %{
	user: user,
	params: params
	} do
	{:ok, _} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _} = CommonAPI.post(user, %{status: "got cofefe?"})
	{:ok, _} = CommonAPI.post(user, %{status: "I am not a boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomers"})
	{:ok, _} = CommonAPI.post(user, %{status: "ccofee is not a word"})
	{:ok, _} = CommonAPI.post(user, %{status: "this is a test"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 6
	end

	test "it does not filter user's own statuses", %{user_two: user_two, params: params} do
	{:ok, _} = CommonAPI.post(user_two, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user_two, %{status: "ok boomer"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.count(activities) == 2
	end

	test "it excludes statuses with filter words", %{user: user, params: params} do
	{:ok, _} = CommonAPI.post(user, %{status: "Give me some cofe!"})
	{:ok, _} = CommonAPI.post(user, %{status: "ok boomer"})
	{:ok, _} = CommonAPI.post(user, %{status: "is it a cOfE?"})
	{:ok, _} = CommonAPI.post(user, %{status: "cofe is all I need"})
	{:ok, _} = CommonAPI.post(user, %{status: "— ok BOOMER\n"})

	activities = ActivityPub.fetch_activities([], params)

	assert Enum.empty?(activities)
	end

	test "it returns all statuses if user does not have any filters" do
	another_user = insert(:user)
	{:ok, _} = CommonAPI.post(another_user, %{status: "got cofe?"})
	{:ok, _} = CommonAPI.post(another_user, %{status: "test!"})

	activities =
	ActivityPub.fetch_activities([], %{
	type: ["Create", "Announce"],
	user: another_user
	})

	assert Enum.count(activities) == 2
	end
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} = CommonAPI.post(user, %{status: "yeah", visibility: "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{status: "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	activities = ActivityPub.fetch_public_activities()

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 20
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	expected_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id

	activities = ActivityPub.fetch_public_activities(%{since_id: since_id})

	assert collect_ids(activities) == collect_ids(expected_activities)
	assert length(activities) == 10
	end

	test "retrieves ids up to max_id" do
	ActivityBuilder.insert_list(10)
	expected_activities = ActivityBuilder.insert_list(20)

	%{id: max_id} =
	10
	\|> ActivityBuilder.insert_list()
	\|> List.first()

	activities = ActivityPub.fetch_public_activities(%{max_id: max_id})

	assert length(activities) == 20
	assert collect_ids(activities) == collect_ids(expected_activities)
	end

	test "paginates via offset/limit" do
	_first_part_activities = ActivityBuilder.insert_list(10)
	second_part_activities = ActivityBuilder.insert_list(10)

	later_activities = ActivityBuilder.insert_list(10)

	activities = ActivityPub.fetch_public_activities(%{page: "2", page_size: "20"}, :offset)

	assert length(activities) == 20

	assert collect_ids(activities) ==
	collect_ids(second_part_activities) ++ collect_ids(later_activities)
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(booster, user)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(booster, user)
	{:ok, _reblog_mute} = CommonAPI.show_reblogs(booster, user)

	{:ok, activity} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{muting_user: user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "uploading files" do
	setup do
	test_file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	%{test_file: test_file}
	end

	test "strips / from filename", %{test_file: file} do
	file = %Plug.Upload{file \| filename: "../../../../../nested/bad.jpg"}
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	[%{"href" => href}] = object.data["url"]
	assert Regex.match?(~r"/bad.jpg$", href)
	refute Regex.match?(~r"/nested/", href)
	end

	test "sets a description if given", %{test_file: file} do
	{:ok, %Object{} = object} = ActivityPub.upload(file, description: "a cool file")
	assert object.data["name"] == "a cool file"
	end

	test "it sets the default description depending on the configuration", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description])

	clear_config([Pleroma.Upload, :default_description], nil)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == ""

	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"

	clear_config([Pleroma.Upload, :default_description], "unnamed attachment")
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "unnamed attachment"
	end

	test "copies the file to the configured folder", %{test_file: file} do
	clear_config([Pleroma.Upload, :default_description], :filename)
	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	img: data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = Repo.get_by(User, ap_id: activity.data["actor"])
	followed = Repo.get_by(User, ap_id: activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "unfollowing" do
	test "it reverts unfollow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)

	with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
	assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
	end

	activity = Activity.get_by_id(follow_activity.id)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id

	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end

	test "creates an undo activity for a pending follow request" do
	follower = insert(:user)
	followed = insert(:user, %{is_locked: true})

	{:ok, _, _, follow_activity} = CommonAPI.follow(followed, follower)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	embedded_object = activity.data["object"]
	assert is_map(embedded_object)
	assert embedded_object["type"] == "Follow"
	assert embedded_object["object"] == followed.ap_id
	assert embedded_object["id"] == follow_activity.data["id"]
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1, user3} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2, user3} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3, user2} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{status: "hi 1"})

	{:ok, private_activity_1} = CommonAPI.post(user3, %{status: "hi 2", visibility: "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	status: "hi 3",
	visibility: "private",
	in_reply_to_status_id: private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	status: "hi 4",
	visibility: "private",
	in_reply_to_status_id: private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| User.following(user1)], %{user: user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "flag/1" do
	setup do
	reporter = insert(:user)
	target_account = insert(:user)
	content = "foobar"
	{:ok, activity} = CommonAPI.post(target_account, %{status: content})
	context = Utils.generate_context_id()

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]
	object_ap_id = activity.object.data["id"]

	activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)

	{:ok,
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: activity,
	content: content,
	activity_ap_id: activity_ap_id,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	}}
	end

	test "it can create a Flag activity",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content,
	object_ap_id: object_ap_id,
	activity_with_object: activity_with_object,
	reporter_ap_id: reporter_ap_id,
	target_ap_id: target_ap_id
	} do
	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	note_obj = %{
	"type" => "Note",
	"id" => object_ap_id,
	"content" => content,
	"published" => activity_with_object.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj]
	}
	} = activity
	end

	test_with_mock "strips status data from Flag, before federating it",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	object_ap_id: object_ap_id,
	content: content
	},
	Utils,
	[:passthrough],
	[] do
	{:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	new_data = put_in(activity.data, ["object"], [target_account.ap_id, object_ap_id])

	assert_called(Utils.maybe_federate(%{activity \| data: new_data}))
	end

	test_with_mock "reverts on error",
	%{
	reporter: reporter,
	context: context,
	target_account: target_account,
	reported_activity: reported_activity,
	content: content
	},
	Utils,
	[:passthrough],
	maybe_federate: fn _ -> {:error, :reverted} end do
	assert {:error, :reverted} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [reported_activity],
	content: content
	})

	assert Repo.aggregate(Activity, :count, :id) == 1
	assert Repo.aggregate(Object, :count, :id) == 1
	assert Repo.aggregate(Notification, :count, :id) == 0
	end
	end

	test "fetch_activities/2 returns activities addressed to a list " do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	{:ok, list} = Pleroma.List.follow(list, member)

	{:ok, activity} = CommonAPI.post(user, %{status: "foobar", visibility: "list:#{list.id}"})

	activity = Repo.preload(activity, :bookmark)
	activity = %Activity{activity \| thread_muted?: !!activity.thread_muted?}

	assert ActivityPub.fetch_activities([], %{user: user}) == [activity]
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end

	describe "fetch_activities_bounded" do
	test "fetches private posts for followed users" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "thought I looked cute might delete later :3",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
	assert result.id == activity.id
	end

	test "fetches only public posts for other users" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe", visibility: "public"})

	{:ok, _private_activity} =
	CommonAPI.post(user, %{
	status: "why is tenshi eating a corndog so cute?",
	visibility: "private"
	})

	[result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
	assert result.id == activity.id
	end
	end

	describe "fetch_follow_information_for_user" do
	test "synchronizes following/followers counters" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/fuser2/followers",
	following_address: "http://localhost:4001/users/fuser2/following"
	)

	{:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
	assert info.follower_count == 527
	assert info.following_count == 267
	end

	test "detects hidden followers" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.hide_follows == false
	end

	test "detects hidden follows" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_closed/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	_ ->
	apply(HttpRequestMock, :request, [env])
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == false
	assert follow_info.hide_follows == true
	end

	test "detects hidden follows/followers for friendica" do
	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:8080/followers/fuser3",
	following_address: "http://localhost:8080/following/fuser3"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 296
	assert follow_info.following_count == 32
	assert follow_info.hide_follows == true
	end

	test "doesn't crash when follower and following counters are hidden" do
	mock(fn env ->
	case env.url do
	"http://localhost:4001/users/masto_hidden_counters/following" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/followers"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
	%Tesla.Env{status: 403, body: ""}

	"http://localhost:4001/users/masto_hidden_counters/followers" ->
	json(
	%{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://localhost:4001/users/masto_hidden_counters/following"
	},
	headers: HttpRequestMock.activitypub_object_headers()
	)

	"http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
	%Tesla.Env{status: 403, body: ""}
	end
	end)

	user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
	following_address: "http://localhost:4001/users/masto_hidden_counters/following"
	)

	{:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)

	assert follow_info.hide_followers == true
	assert follow_info.follower_count == 0
	assert follow_info.hide_follows == true
	assert follow_info.following_count == 0
	end
	end

	describe "fetch_favourites/3" do
	test "returns a favourite activities sorted by adds to favorite" do
	user = insert(:user)
	other_user = insert(:user)
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, a1} = CommonAPI.post(user1, %{status: "bla"})
	{:ok, _a2} = CommonAPI.post(user2, %{status: "traps are happy"})
	{:ok, a3} = CommonAPI.post(user2, %{status: "Trees Are "})
	{:ok, a4} = CommonAPI.post(user2, %{status: "Agent Smith "})
	{:ok, a5} = CommonAPI.post(user1, %{status: "Red or Blue "})

	{:ok, _} = CommonAPI.favorite(a4.id, user)
	{:ok, _} = CommonAPI.favorite(a3.id, other_user)
	{:ok, _} = CommonAPI.favorite(a3.id, user)
	{:ok, _} = CommonAPI.favorite(a5.id, other_user)
	{:ok, _} = CommonAPI.favorite(a5.id, user)
	{:ok, _} = CommonAPI.favorite(a4.id, other_user)
	{:ok, _} = CommonAPI.favorite(a1.id, user)
	{:ok, _} = CommonAPI.favorite(a1.id, other_user)
	result = ActivityPub.fetch_favourites(user)

	assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]

	result = ActivityPub.fetch_favourites(user, %{limit: 2})
	assert Enum.map(result, & &1.id) == [a1.id, a5.id]
	end
	end

	describe "Move activity" do
	test "create" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	follower_move_opted_out = insert(:user, allow_following_move: false)

	User.follow(follower, old_user)
	User.follow(follower_move_opted_out, old_user)

	assert User.following?(follower, old_user)
	assert User.following?(follower_move_opted_out, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true,
	recipients: recipients
	} = activity

	assert old_user.follower_address in recipients

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	refute User.following?(follower, old_user)
	assert User.following?(follower, new_user)

	assert User.following?(follower_move_opted_out, old_user)
	refute User.following?(follower_move_opted_out, new_user)

	activity = %Activity{activity \| object: nil}

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower)

	assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
	end

	test "old user must be in the new user's `also_known_as` list" do
	old_user = insert(:user)
	new_user = insert(:user)

	assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
	ActivityPub.move(old_user, new_user)
	end

	test "do not move remote user following relationships" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower_remote = insert(:user, local: false)

	User.follow(follower_remote, old_user)

	assert User.following?(follower_remote, old_user)

	assert {:ok, activity} = ActivityPub.move(old_user, new_user)

	assert %Activity{
	actor: ^old_ap_id,
	data: %{
	"actor" => ^old_ap_id,
	"object" => ^old_ap_id,
	"target" => ^new_ap_id,
	"type" => "Move"
	},
	local: true
	} = activity

	params = %{
	"op" => "move_following",
	"origin_id" => old_user.id,
	"target_id" => new_user.id
	}

	assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)

	Pleroma.Workers.BackgroundWorker.perform(%Oban.Job{args: params})

	assert User.following?(follower_remote, old_user)
	refute User.following?(follower_remote, new_user)
	end
	end

	test "doesn't retrieve replies activities with exclude_replies" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "yeah"})

	{:ok, _reply} = CommonAPI.post(user, %{status: "yeah", in_reply_to_status_id: activity.id})

	[result] = ActivityPub.fetch_public_activities(%{exclude_replies: true})

	assert result.id == activity.id

	assert length(ActivityPub.fetch_public_activities()) == 2
	end

	describe "replies filtering with public messages" do
	setup :public_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 16
	end

	test "public timeline with reply_visibility `following`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 14

	visible_ids =
	Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "public timeline with reply_visibility `self`", %{
	users: %{u1: user},
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4,
	activities: activities
	} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10
	visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 13

	visible_ids =
	Map.values(u1) ++
	Map.values(u3) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `following`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 11

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u2[:r3],
	u3[:r1],
	u4[:r1],
	u4[:r2]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "home timeline with reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 9

	visible_ids =
	Map.values(u1) ++
	[
	activities[:a1],
	activities[:a2],
	activities[:a4],
	u2[:r1],
	u3[:r1],
	u4[:r1]
	]

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end

	test "filtering out announces where the user is the actor of the announced message" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	User.follow(user, other_user)

	{:ok, post} = CommonAPI.post(user, %{status: "yo"})
	{:ok, other_post} = CommonAPI.post(third_user, %{status: "yo"})
	{:ok, _announce} = CommonAPI.repeat(post.id, other_user)
	{:ok, _announce} = CommonAPI.repeat(post.id, third_user)
	{:ok, announce} = CommonAPI.repeat(other_post.id, other_user)

	params = %{
	type: ["Announce"]
	}

	results =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert length(results) == 3

	params = %{
	type: ["Announce"],
	announce_filtering_user: user
	}

	[result] =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert result.id == announce.id
	end
	end

	describe "replies filtering with private messages" do
	setup :private_messages

	test "public timeline", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []
	end

	test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
	activities_ids =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:local_only, false)
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:user, user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.map(& &1.id)

	assert activities_ids == []

	activities_ids =
	%{}
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, nil)
	\|> ActivityPub.fetch_public_activities()

	assert activities_ids == []
	end

	test "home timeline", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 12
	end

	test "home timeline with default reply_visibility `self`", %{
	users: %{u1: user},
	activities: activities,
	u1: u1,
	u2: u2,
	u3: u3,
	u4: u4
	} do
	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:user, user)
	\|> Map.put(:reply_visibility, "self")
	\|> Map.put(:reply_filtering_user, user)

	activities_ids =
	ActivityPub.fetch_activities([user.ap_id \| User.following(user)], params)
	\|> Enum.map(& &1.id)

	assert length(activities_ids) == 10

	visible_ids =
	Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)

	assert Enum.all?(visible_ids, &(&1 in activities_ids))
	end
	end

	defp public_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, r2_3} =
	CommonAPI.post(u4, %{
	status: "@#{u2.nickname} reply from u4 to u2",
	in_reply_to_status_id: a2.id
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, r3_3} =
	CommonAPI.post(u4, %{
	status: "@#{u3.nickname} reply from u4 to u3",
	in_reply_to_status_id: a3.id
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_2} =
	CommonAPI.post(u2, %{
	status: "@#{u4.nickname} reply from u2 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok, r4_3} =
	CommonAPI.post(u3, %{
	status: "@#{u4.nickname} reply from u3 to u4",
	in_reply_to_status_id: a4.id
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
	u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
	u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
	end

	defp private_messages(_) do
	[u1, u2, u3, u4] = insert_list(4, :user)
	{:ok, u1, u2} = User.follow(u1, u2)
	{:ok, u2, u1} = User.follow(u2, u1)
	{:ok, u1, u3} = User.follow(u1, u3)
	{:ok, u3, u1} = User.follow(u3, u1)
	{:ok, u1, u4} = User.follow(u1, u4)
	{:ok, u4, u1} = User.follow(u4, u1)

	{:ok, u2, u3} = User.follow(u2, u3)
	{:ok, u3, u2} = User.follow(u3, u2)

	{:ok, a1} = CommonAPI.post(u1, %{status: "Status", visibility: "private"})

	{:ok, r1_1} =
	CommonAPI.post(u2, %{
	status: "@#{u1.nickname} reply from u2 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_2} =
	CommonAPI.post(u3, %{
	status: "@#{u1.nickname} reply from u3 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, r1_3} =
	CommonAPI.post(u4, %{
	status: "@#{u1.nickname} reply from u4 to u1",
	in_reply_to_status_id: a1.id,
	visibility: "private"
	})

	{:ok, a2} = CommonAPI.post(u2, %{status: "Status", visibility: "private"})

	{:ok, r2_1} =
	CommonAPI.post(u1, %{
	status: "@#{u2.nickname} reply from u1 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, r2_2} =
	CommonAPI.post(u3, %{
	status: "@#{u2.nickname} reply from u3 to u2",
	in_reply_to_status_id: a2.id,
	visibility: "private"
	})

	{:ok, a3} = CommonAPI.post(u3, %{status: "Status", visibility: "private"})

	{:ok, r3_1} =
	CommonAPI.post(u1, %{
	status: "@#{u3.nickname} reply from u1 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, r3_2} =
	CommonAPI.post(u2, %{
	status: "@#{u3.nickname} reply from u2 to u3",
	in_reply_to_status_id: a3.id,
	visibility: "private"
	})

	{:ok, a4} = CommonAPI.post(u4, %{status: "Status", visibility: "private"})

	{:ok, r4_1} =
	CommonAPI.post(u1, %{
	status: "@#{u4.nickname} reply from u1 to u4",
	in_reply_to_status_id: a4.id,
	visibility: "private"
	})

	{:ok,
	users: %{u1: u1, u2: u2, u3: u3, u4: u4},
	activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
	u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
	u2: %{r1: r2_1.id, r2: r2_2.id},
	u3: %{r1: r3_1.id, r2: r3_2.id},
	u4: %{r1: r4_1.id}}
	end

	describe "maybe_update_follow_information/1" do
	setup do
	clear_config([:instance, :external_user_synchronization], true)

	user = %{
	local: false,
	ap_id: "https://gensokyo.2hu/users/raymoo",
	following_address: "https://gensokyo.2hu/users/following",
	follower_address: "https://gensokyo.2hu/users/followers",
	type: "Person"
	}

	%{user: user}
	end

	test "logs an error when it can't fetch the info", %{user: user} do
	assert capture_log(fn ->
	ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "just returns the input if the user type is Application", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:type, "Application")

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end

	test "it just returns the input if the user has no following/follower addresses", %{
	user: user
	} do
	user =
	user
	\|> Map.put(:following_address, nil)
	\|> Map.put(:follower_address, nil)

	refute capture_log(fn ->
	assert ^user = ActivityPub.maybe_update_follow_information(user)
	end) =~ "Follower/Following counter update for #{user.ap_id} failed"
	end
	end

	describe "global activity expiration" do
	test "creates an activity expiration for local Create activities" do
	clear_config([:mrf, :policies], Pleroma.Web.ActivityPub.MRF.ActivityExpirationPolicy)

	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, follow} = ActivityBuilder.insert(%{"type" => "Follow", "context" => "3hu"})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id},
	scheduled_at:
	activity.inserted_at
	\|> DateTime.from_naive!("Etc/UTC")
	\|> Timex.shift(days: 365)
	)

	refute_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: follow.id}
	)
	end
	end

	describe "handling of clashing nicknames" do
	test "renames an existing user with a clashing nickname and a different ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id <> "part_2"
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == "#{orig_user.id}.admin@mastodon.example.org"
	end

	test "does nothing with a clashing nickname and the same ap id" do
	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/harinezumigari"
	)

	%{
	nickname: orig_user.nickname,
	ap_id: orig_user.ap_id
	}
	\|> ActivityPub.maybe_handle_clashing_nickname()

	user = User.get_by_id(orig_user.id)

	assert user.nickname == orig_user.nickname
	end
	end

	describe "reply filtering" do
	test "`following` still contains announcements by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})

	{:ok, not_followed_to_followed} =
	CommonAPI.post(not_followed, %{
	status: "Also hello",
	in_reply_to_status_id: followed_post.id
	})

	{:ok, retoot} = CommonAPI.repeat(not_followed_to_followed.id, followed)

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	followed_post_id = followed_post.id
	retoot_id = retoot.id

	assert [%{id: ^followed_post_id}, %{id: ^retoot_id}] = activities

	assert length(activities) == 2
	end

	# This test is skipped because, while this is the desired behavior,
	# there seems to be no good way to achieve it with the method that
	# we currently use for detecting to who a reply is directed.
	# This is a TODO and should be fixed by a later rewrite of the code
	# in question.
	@tag skip: true
	test "`following` still contains self-replies by friends" do
	user = insert(:user)
	followed = insert(:user)
	not_followed = insert(:user)

	User.follow(user, followed)

	{:ok, followed_post} = CommonAPI.post(followed, %{status: "Hello"})
	{:ok, not_followed_post} = CommonAPI.post(not_followed, %{status: "Also hello"})

	{:ok, _followed_to_not_followed} =
	CommonAPI.post(followed, %{status: "sup", in_reply_to_status_id: not_followed_post.id})

	{:ok, _followed_self_reply} =
	CommonAPI.post(followed, %{status: "Also cofe", in_reply_to_status_id: followed_post.id})

	params =
	%{}
	\|> Map.put(:type, ["Create", "Announce"])
	\|> Map.put(:blocking_user, user)
	\|> Map.put(:muting_user, user)
	\|> Map.put(:reply_filtering_user, user)
	\|> Map.put(:reply_visibility, "following")
	\|> Map.put(:announce_filtering_user, user)
	\|> Map.put(:user, user)

	activities =
	[user.ap_id \| User.following(user)]
	\|> ActivityPub.fetch_activities(params)

	assert length(activities) == 2
	end
	end

	test "allow fetching of accounts with an empty string name field" do
	Tesla.Mock.mock(fn
	%{method: :get, url: "https://princess.cat/users/mewmew"} ->
	file = File.read!("test/fixtures/mewmew_no_name.json")
	%Tesla.Env{status: 200, body: file, headers: HttpRequestMock.activitypub_object_headers()}
	end)

	{:ok, user} = ActivityPub.make_user_from_ap_id("https://princess.cat/users/mewmew")
	assert user.name == " "
	end

	test "pin_data_from_featured_collection will ignore unsupported values" do
	assert %{} ==
	ActivityPub.pin_data_from_featured_collection(%{
	"type" => "OrderedCollection",
	"first" => "https://social.example/users/alice/collections/featured?page=true"
	})
	end
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs b/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs
	new file mode 100644
	index 000000000..8d2a6b4fa
	--- /dev/null
	+++ b/test/pleroma/web/activity_pub/mrf/remote_report_policy_test.exs
	@@ -0,0 +1,155 @@
	+defmodule Pleroma.Web.ActivityPub.MRF.RemoteReportPolicyTest do
	+ use Pleroma.DataCase, async: true
	+
	+ alias Pleroma.Web.ActivityPub.MRF.RemoteReportPolicy
	+
	+ setup do
	+ clear_config([:mrf_remote_report, :reject_all], false)
	+ end
	+
	+ test "doesn't impact local report" do
	+ clear_config([:mrf_remote_report, :reject_anonymous], true)
	+ clear_config([:mrf_remote_report, :reject_empty_message], true)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "http://localhost:4001/actor",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:ok, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "rejects anonymous report if `reject_anonymous: true`" do
	+ clear_config([:mrf_remote_report, :reject_anonymous], true)
	+ clear_config([:mrf_remote_report, :reject_empty_message], true)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/actor",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:reject, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "preserves anonymous report if `reject_anonymous: false`" do
	+ clear_config([:mrf_remote_report, :reject_anonymous], false)
	+ clear_config([:mrf_remote_report, :reject_empty_message], false)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/actor",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:ok, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "rejects report on third party if `reject_third_party: true`" do
	+ clear_config([:mrf_remote_report, :reject_third_party], true)
	+ clear_config([:mrf_remote_report, :reject_empty_message], false)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/users/Gargron",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:reject, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "preserves report on first party if `reject_third_party: true`" do
	+ clear_config([:mrf_remote_report, :reject_third_party], true)
	+ clear_config([:mrf_remote_report, :reject_empty_message], false)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/users/Gargron",
	+ "object" => ["http://localhost:4001/actor"]
	+ }
	+
	+ assert {:ok, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "preserves report on third party if `reject_third_party: false`" do
	+ clear_config([:mrf_remote_report, :reject_third_party], false)
	+ clear_config([:mrf_remote_report, :reject_empty_message], false)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/users/Gargron",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:ok, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "rejects empty message report if `reject_empty_message: true`" do
	+ clear_config([:mrf_remote_report, :reject_anonymous], false)
	+ clear_config([:mrf_remote_report, :reject_empty_message], true)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/users/Gargron",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:reject, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "rejects empty message report (\"\") if `reject_empty_message: true`" do
	+ clear_config([:mrf_remote_report, :reject_anonymous], false)
	+ clear_config([:mrf_remote_report, :reject_empty_message], true)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/users/Gargron",
	+ "object" => ["https://mastodon.online/users/Gargron"],
	+ "content" => ""
	+ }
	+
	+ assert {:reject, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "preserves empty message report if `reject_empty_message: false`" do
	+ clear_config([:mrf_remote_report, :reject_anonymous], false)
	+ clear_config([:mrf_remote_report, :reject_empty_message], false)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/users/Gargron",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:ok, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "preserves anonymous, empty message report with all settings disabled" do
	+ clear_config([:mrf_remote_report, :reject_anonymous], false)
	+ clear_config([:mrf_remote_report, :reject_empty_message], false)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/actor",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:ok, _} = RemoteReportPolicy.filter(activity)
	+ end
	+
	+ test "reject remote report if `reject_all: true`" do
	+ clear_config([:mrf_remote_report, :reject_all], true)
	+ clear_config([:mrf_remote_report, :reject_anonymous], false)
	+ clear_config([:mrf_remote_report, :reject_empty_message], false)
	+
	+ activity = %{
	+ "type" => "Flag",
	+ "actor" => "https://mastodon.social/users/Gargron",
	+ "content" => "Transphobia",
	+ "object" => ["https://mastodon.online/users/Gargron"]
	+ }
	+
	+ assert {:reject, _} = RemoteReportPolicy.filter(activity)
	+ end
	+end
	diff --git a/test/pleroma/web/activity_pub/mrf/simple_policy_test.exs b/test/pleroma/web/activity_pub/mrf/simple_policy_test.exs
	index 1a51b7d30..f49a7b8ff 100644
	--- a/test/pleroma/web/activity_pub/mrf/simple_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/simple_policy_test.exs
	@@ -1,579 +1,594 @@
	# 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.MRF.SimplePolicyTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Web.ActivityPub.MRF.SimplePolicy
	alias Pleroma.Web.CommonAPI

	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: []
	)

	describe "when :media_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :media_removal], [])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) == {:ok, media_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :media_removal], [{"remote.instance", "Some reason"}])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> Map.put("object", Map.delete(media_message["object"], "attachment"))}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :media_removal], [{"*.remote.instance", "Whatever reason"}])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> Map.put("object", Map.delete(media_message["object"], "attachment"))}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "works with Updates" do
	clear_config([:mrf_simple, :media_removal], [{"remote.instance", "Some reason"}])
	media_message = build_media_message(type: "Update")

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> Map.put("object", Map.delete(media_message["object"], "attachment"))}
	end
	end

	describe "when :media_nsfw" do
	test "is empty" do
	clear_config([:mrf_simple, :media_nsfw], [])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) == {:ok, media_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :media_nsfw], [{"remote.instance", "Whetever"}])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok, put_in(media_message, ["object", "sensitive"], true)}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :media_nsfw], [{"*.remote.instance", "yeah yeah"}])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok, put_in(media_message, ["object", "sensitive"], true)}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "works with Updates" do
	clear_config([:mrf_simple, :media_nsfw], [{"remote.instance", "Whetever"}])
	media_message = build_media_message(type: "Update")

	assert SimplePolicy.filter(media_message) ==
	{:ok, put_in(media_message, ["object", "sensitive"], true)}
	end
	end

	defp build_media_message(opts \\ []) do
	%{
	"actor" => "https://remote.instance/users/bob",
	"type" => opts[:type] \|\| "Create",
	"object" => %{
	"attachment" => [%{}],
	"tag" => ["foo"],
	"sensitive" => false
	}
	}
	end

	describe "when :report_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :report_removal], [])
	report_message = build_report_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(report_message) == {:ok, report_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :report_removal], [{"remote.instance", "muh"}])
	report_message = build_report_message()
	local_message = build_local_message()

	assert {:reject, _} = SimplePolicy.filter(report_message)
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :report_removal], [{"*.remote.instance", "suya"}])
	report_message = build_report_message()
	local_message = build_local_message()

	assert {:reject, _} = SimplePolicy.filter(report_message)
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end
	end

	defp build_report_message do
	%{
	"actor" => "https://remote.instance/users/bob",
	"type" => "Flag"
	}
	end

	describe "when :federated_timeline_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :federated_timeline_removal], [])
	{_, ftl_message} = build_ftl_actor_and_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	{actor, ftl_message} = build_ftl_actor_and_message()

	ftl_message_actor_host =
	ftl_message
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	clear_config([:mrf_simple, :federated_timeline_removal], [{ftl_message_actor_host, "uwu"}])
	local_message = build_local_message()

	assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
	assert actor.follower_address in ftl_message["to"]
	refute actor.follower_address in ftl_message["cc"]
	refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "match with wildcard domain" do
	{actor, ftl_message} = build_ftl_actor_and_message()

	ftl_message_actor_host =
	ftl_message
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	clear_config([:mrf_simple, :federated_timeline_removal], [
	{"*." <> ftl_message_actor_host, "owo"}
	])

	local_message = build_local_message()

	assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
	assert actor.follower_address in ftl_message["to"]
	refute actor.follower_address in ftl_message["cc"]
	refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host but only as:Public in to" do
	{_actor, ftl_message} = build_ftl_actor_and_message()

	ftl_message_actor_host =
	ftl_message
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	ftl_message = Map.put(ftl_message, "cc", [])

	clear_config([:mrf_simple, :federated_timeline_removal], [
	{ftl_message_actor_host, "spiderwaifu goes 88w88"}
	])

	assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
	refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
	end
	end

	defp build_ftl_actor_and_message do
	actor = insert(:user)

	{actor,
	%{
	"actor" => actor.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
	"cc" => [actor.follower_address, "http://foo.bar/qux"]
	}}
	end

	describe "when :reject" do
	test "is empty" do
	clear_config([:mrf_simple, :reject], [])

	remote_message = build_remote_message()

	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	+ assert SimplePolicy.id_filter(remote_message["actor"])
	end

	test "activity has a matching host" do
	clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])

	remote_message = build_remote_message()

	assert {:reject, _} = SimplePolicy.filter(remote_message)
	+ refute SimplePolicy.id_filter(remote_message["actor"])
	end

	test "activity matches with wildcard domain" do
	clear_config([:mrf_simple, :reject], [{"*.remote.instance", ""}])

	remote_message = build_remote_message()

	assert {:reject, _} = SimplePolicy.filter(remote_message)
	+ refute SimplePolicy.id_filter(remote_message["actor"])
	end

	test "actor has a matching host" do
	clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])

	remote_user = build_remote_user()

	assert {:reject, _} = SimplePolicy.filter(remote_user)
	+ refute SimplePolicy.id_filter(remote_user["id"])
	end

	test "reject Announce when object would be rejected" do
	clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])

	announce = %{
	"type" => "Announce",
	"actor" => "https://okay.tld/users/alice",
	"object" => %{"type" => "Note", "actor" => "https://blocked.tld/users/bob"}
	}

	assert {:reject, _} = SimplePolicy.filter(announce)
	+ # Note: Non-Applicable for id_filter/1
	end

	test "reject by URI object" do
	clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])

	announce = %{
	"type" => "Announce",
	"actor" => "https://okay.tld/users/alice",
	"object" => "https://blocked.tld/activities/1"
	}

	assert {:reject, _} = SimplePolicy.filter(announce)
	+ # Note: Non-Applicable for id_filter/1
	end
	end

	describe "when :followers_only" do
	test "is empty" do
	clear_config([:mrf_simple, :followers_only], [])
	{_, ftl_message} = build_ftl_actor_and_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	actor = insert(:user)
	following_user = insert(:user)
	non_following_user = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(actor, following_user)

	activity = %{
	"actor" => actor.ap_id,
	"to" => [
	"https://www.w3.org/ns/activitystreams#Public",
	following_user.ap_id,
	non_following_user.ap_id
	],
	"cc" => [actor.follower_address, "http://foo.bar/qux"]
	}

	dm_activity = %{
	"actor" => actor.ap_id,
	"to" => [
	following_user.ap_id,
	non_following_user.ap_id
	],
	"cc" => []
	}

	actor_domain =
	activity
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	clear_config([:mrf_simple, :followers_only], [{actor_domain, ""}])

	assert {:ok, new_activity} = SimplePolicy.filter(activity)
	assert actor.follower_address in new_activity["cc"]
	assert following_user.ap_id in new_activity["to"]
	refute "https://www.w3.org/ns/activitystreams#Public" in new_activity["to"]
	refute "https://www.w3.org/ns/activitystreams#Public" in new_activity["cc"]
	refute non_following_user.ap_id in new_activity["to"]
	refute non_following_user.ap_id in new_activity["cc"]

	assert {:ok, new_dm_activity} = SimplePolicy.filter(dm_activity)
	assert new_dm_activity["to"] == [following_user.ap_id]
	assert new_dm_activity["cc"] == []
	end
	end

	describe "when :accept" do
	test "is empty" do
	clear_config([:mrf_simple, :accept], [])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	+ assert SimplePolicy.id_filter(local_message["actor"])
	+ assert SimplePolicy.id_filter(remote_message["actor"])
	end

	test "is not empty but activity doesn't have a matching host" do
	clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert {:reject, _} = SimplePolicy.filter(remote_message)
	+ assert SimplePolicy.id_filter(local_message["actor"])
	+ refute SimplePolicy.id_filter(remote_message["actor"])
	end

	test "activity has a matching host" do
	clear_config([:mrf_simple, :accept], [{"remote.instance", ""}])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	+ assert SimplePolicy.id_filter(local_message["actor"])
	+ assert SimplePolicy.id_filter(remote_message["actor"])
	end

	test "activity matches with wildcard domain" do
	clear_config([:mrf_simple, :accept], [{"*.remote.instance", ""}])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	+ assert SimplePolicy.id_filter(local_message["actor"])
	+ assert SimplePolicy.id_filter(remote_message["actor"])
	end

	test "actor has a matching host" do
	clear_config([:mrf_simple, :accept], [{"remote.instance", ""}])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	+ assert SimplePolicy.id_filter(remote_user["id"])
	end
	end

	describe "when :avatar_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :avatar_removal], [])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end

	test "is not empty but it doesn't have a matching host" do
	clear_config([:mrf_simple, :avatar_removal], [{"non.matching.remote", ""}])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :avatar_removal], [{"remote.instance", ""}])

	remote_user = build_remote_user()
	{:ok, filtered} = SimplePolicy.filter(remote_user)

	refute filtered["icon"]
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :avatar_removal], [{"*.remote.instance", ""}])

	remote_user = build_remote_user()
	{:ok, filtered} = SimplePolicy.filter(remote_user)

	refute filtered["icon"]
	end
	end

	describe "when :banner_removal" do
	test "is empty" do
	clear_config([:mrf_simple, :banner_removal], [])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end

	test "is not empty but it doesn't have a matching host" do
	clear_config([:mrf_simple, :banner_removal], [{"non.matching.remote", ""}])

	remote_user = build_remote_user()

	assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	end

	test "has a matching host" do
	clear_config([:mrf_simple, :banner_removal], [{"remote.instance", ""}])

	remote_user = build_remote_user()
	{:ok, filtered} = SimplePolicy.filter(remote_user)

	refute filtered["image"]
	end

	test "match with wildcard domain" do
	clear_config([:mrf_simple, :banner_removal], [{"*.remote.instance", ""}])

	remote_user = build_remote_user()
	{:ok, filtered} = SimplePolicy.filter(remote_user)

	refute filtered["image"]
	end
	end

	describe "when :reject_deletes is empty" do
	setup do: clear_config([:mrf_simple, :reject_deletes], [])

	test "it accepts deletions even from rejected servers" do
	clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])

	deletion_message = build_remote_deletion_message()

	assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
	end

	test "it accepts deletions even from non-whitelisted servers" do
	clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])

	deletion_message = build_remote_deletion_message()

	assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
	end
	end

	describe "when :reject_deletes is not empty but it doesn't have a matching host" do
	setup do: clear_config([:mrf_simple, :reject_deletes], [{"non.matching.remote", ""}])

	test "it accepts deletions even from rejected servers" do
	clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])

	deletion_message = build_remote_deletion_message()

	assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
	end

	test "it accepts deletions even from non-whitelisted servers" do
	clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])

	deletion_message = build_remote_deletion_message()

	assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
	end
	end

	describe "when :reject_deletes has a matching host" do
	setup do: clear_config([:mrf_simple, :reject_deletes], [{"remote.instance", ""}])

	test "it rejects the deletion" do
	deletion_message = build_remote_deletion_message()

	assert {:reject, _} = SimplePolicy.filter(deletion_message)
	end
	end

	describe "when :reject_deletes match with wildcard domain" do
	setup do: clear_config([:mrf_simple, :reject_deletes], [{"*.remote.instance", ""}])

	test "it rejects the deletion" do
	deletion_message = build_remote_deletion_message()

	assert {:reject, _} = SimplePolicy.filter(deletion_message)
	end
	end

	defp build_local_message do
	%{
	"actor" => "#{Pleroma.Web.Endpoint.url()}/users/alice",
	"to" => [],
	"cc" => []
	}
	end

	defp build_remote_message do
	%{"actor" => "https://remote.instance/users/bob"}
	end

	defp build_remote_user do
	%{
	"id" => "https://remote.instance/users/bob",
	"icon" => %{
	"url" => "http://example.com/image.jpg",
	"type" => "Image"
	},
	"image" => %{
	"url" => "http://example.com/image.jpg",
	"type" => "Image"
	},
	"type" => "Person"
	}
	end

	defp build_remote_deletion_message do
	%{
	"type" => "Delete",
	"actor" => "https://remote.instance/users/bob"
	}
	end
	end
	diff --git a/test/pleroma/web/activity_pub/views/user_view_test.exs b/test/pleroma/web/activity_pub/views/user_view_test.exs
	index 651e535ac..a32e72829 100644
	--- a/test/pleroma/web/activity_pub/views/user_view_test.exs
	+++ b/test/pleroma/web/activity_pub/views/user_view_test.exs
	@@ -1,195 +1,212 @@
	# 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.UserViewTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.CommonAPI

	test "Renders a user, including the public key" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["preferredUsername"] == user.nickname

	assert String.contains?(result["publicKey"]["publicKeyPem"], "BEGIN PUBLIC KEY")
	end

	test "Renders profile fields" do
	fields = [
	%{"name" => "foo", "value" => "bar"}
	]

	{:ok, user} =
	insert(:user)
	\|> User.update_changeset(%{fields: fields})
	\|> User.update_and_set_cache()

	assert %{
	"attachment" => [%{"name" => "foo", "type" => "PropertyValue", "value" => "bar"}]
	} = UserView.render("user.json", %{user: user})
	end

	test "Renders with emoji tags" do
	user = insert(:user, emoji: %{"bib" => "/test"})

	assert %{
	"tag" => [
	%{
	"icon" => %{"type" => "Image", "url" => "/test"},
	"id" => "/test",
	"name" => ":bib:",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z"
	}
	]
	} = UserView.render("user.json", %{user: user})
	end

	test "Does not add an avatar image if the user hasn't set one" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})
	refute result["icon"]
	refute result["image"]

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://someurl"}]},
	banner: %{"url" => [%{"href" => "https://somebanner"}]}
	)

	result = UserView.render("user.json", %{user: user})
	assert result["icon"]["url"] == "https://someurl"
	assert result["image"]["url"] == "https://somebanner"
	+
	+ refute result["icon"]["name"]
	+ refute result["image"]["name"]
	+ end
	+
	+ test "Avatar has a description if the user set one" do
	+ user =
	+ insert(:user,
	+ avatar: %{
	+ "url" => [%{"href" => "https://someurl"}],
	+ "name" => "a drawing of pleroma-tan using pleroma groups"
	+ }
	+ )
	+
	+ result = UserView.render("user.json", %{user: user})
	+
	+ assert result["icon"]["name"] == "a drawing of pleroma-tan using pleroma groups"
	end

	test "renders an invisible user with the invisible property set to true" do
	user = insert(:user, invisible: true)

	assert %{"invisible" => true} = UserView.render("service.json", %{user: user})
	end

	test "service has a few essential fields" do
	user = insert(:user)
	result = UserView.render("service.json", %{user: user})
	assert result["id"]
	assert result["type"] == "Application"
	assert result["inbox"]
	assert result["outbox"]
	end

	test "renders AKAs" do
	akas = ["https://i.tusooa.xyz/users/test-pleroma"]
	user = insert(:user, also_known_as: akas)
	assert %{"alsoKnownAs" => ^akas} = UserView.render("user.json", %{user: user})
	end

	test "renders full nickname" do
	clear_config([Pleroma.Web.WebFinger, :domain], "plemora.dev")

	user = insert(:user, nickname: "user")
	assert %{"webfinger" => "acct:user@plemora.dev"} = UserView.render("user.json", %{user: user})
	end

	describe "endpoints" do
	test "local users have a usable endpoints structure" do
	user = insert(:user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id

	%{
	"sharedInbox" => _,
	"oauthAuthorizationEndpoint" => _,
	"oauthRegistrationEndpoint" => _,
	"oauthTokenEndpoint" => _
	} = result["endpoints"]
	end

	test "remote users have an empty endpoints structure" do
	user = insert(:user, local: false)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["endpoints"] == %{}
	end

	test "instance users do not expose oAuth endpoints" do
	user = insert(:user, nickname: nil, local: true)

	result = UserView.render("user.json", %{user: user})

	refute result["endpoints"]["oauthAuthorizationEndpoint"]
	refute result["endpoints"]["oauthRegistrationEndpoint"]
	refute result["endpoints"]["oauthTokenEndpoint"]
	end
	end

	describe "followers" do
	test "sets totalItems to zero when followers are hidden" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	user = Map.merge(user, %{hide_followers_count: true, hide_followers: true})
	refute UserView.render("followers.json", %{user: user}) \|> Map.has_key?("totalItems")
	end

	test "sets correct totalItems when followers are hidden but the follower counter is not" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user, _other_user, _activity} = CommonAPI.follow(user, other_user)
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	user = Map.merge(user, %{hide_followers_count: false, hide_followers: true})
	assert %{"totalItems" => 1} = UserView.render("followers.json", %{user: user})
	end
	end

	describe "following" do
	test "sets totalItems to zero when follows are hidden" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	user = Map.merge(user, %{hide_follows_count: true, hide_follows: true})
	assert %{"totalItems" => 0} = UserView.render("following.json", %{user: user})
	end

	test "sets correct totalItems when follows are hidden but the follow counter is not" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	user = Map.merge(user, %{hide_follows_count: false, hide_follows: true})
	assert %{"totalItems" => 1} = UserView.render("following.json", %{user: user})
	end
	end

	describe "acceptsChatMessages" do
	test "it returns this value if it is set" do
	true_user = insert(:user, accepts_chat_messages: true)
	false_user = insert(:user, accepts_chat_messages: false)
	nil_user = insert(:user, accepts_chat_messages: nil)

	assert %{"capabilities" => %{"acceptsChatMessages" => true}} =
	UserView.render("user.json", user: true_user)

	assert %{"capabilities" => %{"acceptsChatMessages" => false}} =
	UserView.render("user.json", user: false_user)

	refute Map.has_key?(
	UserView.render("user.json", user: nil_user)["capabilities"],
	"acceptsChatMessages"
	)
	end
	end
	end
	diff --git a/test/pleroma/web/feed/tag_controller_test.exs b/test/pleroma/web/feed/tag_controller_test.exs
	index 7d196b228..662235f31 100644
	--- a/test/pleroma/web/feed/tag_controller_test.exs
	+++ b/test/pleroma/web/feed/tag_controller_test.exs
	@@ -1,194 +1,250 @@
	# 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.TagControllerTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory
	import SweetXml

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Feed.FeedView

	setup do: clear_config([:feed])

	test "gets a feed (ATOM)", %{conn: conn} do
	clear_config(
	[:feed, :post_title],
	%{max_length: 25, omission: "..."}
	)

	user = insert(:user)
	{:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})

	object = Object.normalize(activity1, fetch: false)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	{:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})

	{:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})

	response =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.atom"))
	\|> response(200)

	xml = parse(response)

	assert xpath(xml, ~x"//feed/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//feed/entry/title/text()"l) == [
	~c"42 This is :moominmamm...",
	~c"yeah #PleromaArt"
	]

	assert xpath(xml, ~x"//feed/entry/author/name/text()"ls) == [user.nickname, user.nickname]

	conn =
	conn
	\|> put_req_header("accept", "application/atom+xml")
	\|> get("/tags/pleromaart.atom", %{"max_id" => activity2.id})

	assert get_resp_header(conn, "content-type") == ["application/atom+xml; charset=utf-8"]
	resp = response(conn, 200)
	xml = parse(resp)

	assert xpath(xml, ~x"//feed/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//feed/entry/title/text()"l) == [
	~c"yeah #PleromaArt"
	]
	end

	test "gets a feed (RSS)", %{conn: conn} do
	clear_config(
	[:feed, :post_title],
	%{max_length: 25, omission: "..."}
	)

	user = insert(:user)
	{:ok, activity1} = CommonAPI.post(user, %{status: "yeah #PleromaArt"})

	object = Object.normalize(activity1, fetch: false)

	object_data =
	Map.put(object.data, "attachment", [
	%{
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	]
	}
	])

	object
	\|> Ecto.Changeset.change(data: object_data)
	\|> Pleroma.Repo.update()

	{:ok, activity2} = CommonAPI.post(user, %{status: "42 This is :moominmamma #PleromaArt"})

	{:ok, _activity3} = CommonAPI.post(user, %{status: "This is :moominmamma"})

	response =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(200)

	xml = parse(response)
	assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//channel/description/text()"s) ==
	"These are public toots tagged with #pleromaart. You can interact with them if you have an account anywhere in the fediverse."

	assert xpath(xml, ~x"//channel/link/text()") ==
	~c"#{Pleroma.Web.Endpoint.url()}/tags/pleromaart.rss"

	assert xpath(xml, ~x"//channel/webfeeds:logo/text()") ==
	~c"#{Pleroma.Web.Endpoint.url()}/static/logo.svg"

	assert xpath(xml, ~x"//channel/item/title/text()"l) == [
	~c"42 This is :moominmamm...",
	~c"yeah #PleromaArt"
	]

	assert xpath(xml, ~x"//channel/item/pubDate/text()"sl) == [
	FeedView.to_rfc2822(activity2.data["published"]),
	FeedView.to_rfc2822(activity1.data["published"])
	]

	assert xpath(xml, ~x"//channel/item/enclosure/@url"sl) == [
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4"
	]

	obj1 = Object.normalize(activity1, fetch: false)
	obj2 = Object.normalize(activity2, fetch: false)

	assert xpath(xml, ~x"//channel/item/description/text()"sl) == [
	HtmlEntities.decode(FeedView.activity_content(obj2.data)),
	HtmlEntities.decode(FeedView.activity_content(obj1.data))
	]

	response =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(200)

	xml = parse(response)
	assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//channel/description/text()"s) ==
	"These are public toots tagged with #pleromaart. You can interact with them if you have an account anywhere in the fediverse."

	conn =
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get("/tags/pleromaart.rss", %{"max_id" => activity2.id})

	assert get_resp_header(conn, "content-type") == ["application/rss+xml; charset=utf-8"]
	resp = response(conn, 200)
	xml = parse(resp)

	assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"

	assert xpath(xml, ~x"//channel/item/title/text()"l) == [
	~c"yeah #PleromaArt"
	]
	end

	describe "private instance" do
	setup do: clear_config([:instance, :public], false)

	test "returns 404 for tags feed", %{conn: conn} do
	conn
	\|> put_req_header("accept", "application/rss+xml")
	\|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	\|> response(404)
	end
	end
	+
	+ describe "restricted for unauthenticated" do
	+ test "returns 404 when local timeline is disabled", %{conn: conn} do
	+ clear_config([:restrict_unauthenticated, :timelines], %{local: true, federated: false})
	+
	+ conn
	+ \|> put_req_header("accept", "application/rss+xml")
	+ \|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	+ \|> response(404)
	+ end
	+
	+ test "returns local posts only when federated timeline is disabled", %{conn: conn} do
	+ clear_config([:restrict_unauthenticated, :timelines], %{local: false, federated: true})
	+
	+ local_user = insert(:user)
	+ remote_user = insert(:user, local: false)
	+
	+ local_note =
	+ insert(:note,
	+ user: local_user,
	+ data: %{
	+ "content" => "local post #PleromaArt",
	+ "summary" => "",
	+ "tag" => ["pleromaart"]
	+ }
	+ )
	+
	+ remote_note =
	+ insert(:note,
	+ user: remote_user,
	+ data: %{
	+ "content" => "remote post #PleromaArt",
	+ "summary" => "",
	+ "tag" => ["pleromaart"]
	+ },
	+ local: false
	+ )
	+
	+ insert(:note_activity, user: local_user, note: local_note)
	+ insert(:note_activity, user: remote_user, note: remote_note, local: false)
	+
	+ response =
	+ conn
	+ \|> put_req_header("accept", "application/rss+xml")
	+ \|> get(tag_feed_path(conn, :feed, "pleromaart.rss"))
	+ \|> response(200)
	+
	+ xml = parse(response)
	+
	+ assert xpath(xml, ~x"//channel/title/text()") == ~c"#pleromaart"
	+
	+ assert xpath(xml, ~x"//channel/item/title/text()"l) == [
	+ ~c"local post #PleromaArt"
	+ ]
	+ end
	+ end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/media_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/media_controller_test.exs
	index 4adbaa640..3f696d94d 100644
	--- a/test/pleroma/web/mastodon_api/controllers/media_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/media_controller_test.exs
	@@ -1,230 +1,230 @@
	# 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.MediaControllerTest do
	use Pleroma.Web.ConnCase

	import ExUnit.CaptureLog
	import Mox

	alias Pleroma.Object
	alias Pleroma.UnstubbedConfigMock, as: ConfigMock
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub

	describe "Upload media" do
	setup do: oauth_access(["write:media"])

	setup do
	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	image = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	[image: image]
	end

	setup do: clear_config([:media_proxy])
	setup do: clear_config([Pleroma.Upload])

	test "/api/v1/media", %{conn: conn, image: image} do
	desc = "Description of the image"

	media =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/media", %{"file" => image, "description" => desc})
	\|> json_response_and_validate_schema(:ok)

	assert media["type"] == "image"
	assert media["description"] == desc
	assert media["id"]

	object = Object.get_by_id(media["id"])
	assert object.data["actor"] == User.ap_id(conn.assigns[:user])
	end

	test "/api/v2/media", %{conn: conn, user: user, image: image} do
	desc = "Description of the image"

	response =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v2/media", %{"file" => image, "description" => desc})
	- \|> json_response_and_validate_schema(202)
	+ \|> json_response_and_validate_schema(200)

	assert media_id = response["id"]

	%{conn: conn} = oauth_access(["read:media"], user: user)

	media =
	conn
	\|> get("/api/v1/media/#{media_id}")
	\|> json_response_and_validate_schema(200)

	assert media["type"] == "image"
	assert media["description"] == desc
	assert media["id"]

	object = Object.get_by_id(media["id"])
	assert object.data["actor"] == user.ap_id
	end

	test "/api/v2/media, upload_limit", %{conn: conn, user: user} do
	clear_config([Pleroma.Upload, :uploader], Pleroma.Uploaders.Local)
	desc = "Description of the binary"

	upload_limit = Config.get([:instance, :upload_limit]) * 8 + 8

	assert :ok ==
	File.write(Path.absname("test/tmp/large_binary.data"), <<0::size(upload_limit)>>)

	large_binary = %Plug.Upload{
	content_type: nil,
	path: Path.absname("test/tmp/large_binary.data"),
	filename: "large_binary.data"
	}

	assert capture_log(fn ->
	assert %{"error" => "file_too_large"} =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v2/media", %{
	"file" => large_binary,
	"description" => desc
	})
	\|> json_response_and_validate_schema(400)
	end) =~
	"[error] Elixir.Pleroma.Upload store (using Pleroma.Uploaders.Local) failed: :file_too_large"

	clear_config([:instance, :upload_limit], upload_limit)

	assert response =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v2/media", %{
	"file" => large_binary,
	"description" => desc
	})
	- \|> json_response_and_validate_schema(202)
	+ \|> json_response_and_validate_schema(200)

	assert media_id = response["id"]

	%{conn: conn} = oauth_access(["read:media"], user: user)

	media =
	conn
	\|> get("/api/v1/media/#{media_id}")
	\|> json_response_and_validate_schema(200)

	assert media["type"] == "unknown"
	assert media["description"] == desc
	assert media["id"]

	assert :ok == File.rm(Path.absname("test/tmp/large_binary.data"))
	end

	test "Do not allow nested filename", %{conn: conn, image: image} do
	image = %Plug.Upload{
	image
	\| filename: "../../../../../nested/file.jpg"
	}

	desc = "Description of the image"

	media =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> post("/api/v1/media", %{"file" => image, "description" => desc})
	\|> json_response_and_validate_schema(:ok)

	refute Regex.match?(~r"/nested/", media["url"])
	end
	end

	describe "Update media description" do
	setup do: oauth_access(["write:media"])

	setup %{user: actor} do
	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %Object{} = object} =
	ActivityPub.upload(
	file,
	actor: User.ap_id(actor),
	description: "test-m"
	)

	[object: object]
	end

	test "/api/v1/media/:id good request", %{conn: conn, object: object} do
	media =
	conn
	\|> put_req_header("content-type", "multipart/form-data")
	\|> put("/api/v1/media/#{object.id}", %{"description" => "test-media"})
	\|> json_response_and_validate_schema(:ok)

	assert media["description"] == "test-media"
	assert refresh_record(object).data["name"] == "test-media"
	end
	end

	describe "Get media by id (/api/v1/media/:id)" do
	setup do: oauth_access(["read:media"])

	setup %{user: actor} do
	ConfigMock
	\|> stub_with(Pleroma.Test.StaticConfig)

	file = %Plug.Upload{
	content_type: "image/jpeg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %Object{} = object} =
	ActivityPub.upload(
	file,
	actor: User.ap_id(actor),
	description: "test-media"
	)

	[object: object]
	end

	test "it returns media object when requested by owner", %{conn: conn, object: object} do
	media =
	conn
	\|> get("/api/v1/media/#{object.id}")
	\|> json_response_and_validate_schema(:ok)

	assert media["description"] == "test-media"
	assert media["type"] == "image"
	assert media["id"]
	end

	test "it returns 403 if media object requested by non-owner", %{object: object, user: user} do
	%{conn: conn, user: other_user} = oauth_access(["read:media"])

	assert object.data["actor"] == user.ap_id
	refute user.id == other_user.id

	conn
	\|> get("/api/v1/media/#{object.id}")
	\|> json_response_and_validate_schema(403)
	end
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs
	index 7912b1d5f..51af87742 100644
	--- a/test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/poll_controller_test.exs
	@@ -1,242 +1,270 @@
	# 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.PollControllerTest do
	+ use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.Web.ConnCase, async: true

	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "GET /api/v1/polls/:id" do
	setup do: oauth_access(["read:statuses"])

	test "returns poll entity for object id", %{user: user, conn: conn} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Pleroma does",
	poll: %{options: ["what Mastodon't", "n't what Mastodoes"], expires_in: 20}
	})

	object = Object.normalize(activity, fetch: false)

	conn = get(conn, "/api/v1/polls/#{object.id}")

	response = json_response_and_validate_schema(conn, 200)
	id = to_string(object.id)
	assert %{"id" => ^id, "expired" => false, "multiple" => false} = response
	+
	+ # Local activities should not generate an Oban job to refresh
	+ assert activity.local
	+
	+ refute_enqueued(
	+ worker: Pleroma.Workers.PollWorker,
	+ args: %{"op" => "refresh", "activity_id" => activity.id}
	+ )
	+ end
	+
	+ test "creates an oban job to refresh poll if activity is remote", %{conn: conn} do
	+ user = insert(:user, local: false)
	+ question = insert(:question, user: user)
	+ activity = insert(:question_activity, question: question, local: false)
	+
	+ # Ensure this is not represented as a local activity
	+ refute activity.local
	+
	+ object = Object.normalize(activity, fetch: false)
	+
	+ get(conn, "/api/v1/polls/#{object.id}")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert_enqueued(
	+ worker: Pleroma.Workers.PollWorker,
	+ args: %{"op" => "refresh", "activity_id" => activity.id}
	+ )
	end

	test "does not expose polls for private statuses", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "Pleroma does",
	poll: %{options: ["what Mastodon't", "n't what Mastodoes"], expires_in: 20},
	visibility: "private"
	})

	object = Object.normalize(activity, fetch: false)

	conn = get(conn, "/api/v1/polls/#{object.id}")

	assert json_response_and_validate_schema(conn, 404)
	end
	end

	test "own_votes" do
	%{conn: conn} = oauth_access(["write:statuses", "read:statuses"])

	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "A very delicious sandwich",
	poll: %{
	options: ["Lettuce", "Grilled Bacon", "Tomato"],
	expires_in: 20,
	multiple: true
	}
	})

	object = Object.normalize(activity, fetch: false)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 2]})
	\|> json_response_and_validate_schema(200)

	object = Object.get_by_id(object.id)

	assert [
	%{
	"name" => "Lettuce",
	"replies" => %{"totalItems" => 1, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "Grilled Bacon",
	"replies" => %{"totalItems" => 0, "type" => "Collection"},
	"type" => "Note"
	},
	%{
	"name" => "Tomato",
	"replies" => %{"totalItems" => 1, "type" => "Collection"},
	"type" => "Note"
	}
	] == object.data["anyOf"]

	assert %{"replies" => %{"totalItems" => 0}} =
	Enum.find(object.data["anyOf"], fn %{"name" => name} -> name == "Grilled Bacon" end)

	Enum.each(["Lettuce", "Tomato"], fn title ->
	%{"replies" => %{"totalItems" => total_items}} =
	Enum.find(object.data["anyOf"], fn %{"name" => name} -> name == title end)

	assert total_items == 1
	end)

	assert %{
	"own_votes" => own_votes,
	"voted" => true
	} =
	conn
	\|> get("/api/v1/polls/#{object.id}")
	\|> json_response_and_validate_schema(200)

	assert 0 in own_votes
	assert 2 in own_votes
	# for non authenticated user
	response =
	build_conn()
	\|> get("/api/v1/polls/#{object.id}")
	\|> json_response_and_validate_schema(200)

	refute Map.has_key?(response, "own_votes")
	refute Map.has_key?(response, "voted")
	end

	describe "POST /api/v1/polls/:id/votes" do
	setup do: oauth_access(["write:statuses"])

	test "votes are added to the poll", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "A very delicious sandwich",
	poll: %{
	options: ["Lettuce", "Grilled Bacon", "Tomato"],
	expires_in: 20,
	multiple: true
	}
	})

	object = Object.normalize(activity, fetch: false)

	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1, 2]})
	\|> json_response_and_validate_schema(200)

	object = Object.get_by_id(object.id)

	assert Enum.all?(object.data["anyOf"], fn %{"replies" => %{"totalItems" => total_items}} ->
	total_items == 1
	end)
	end

	test "author can't vote", %{user: user, conn: conn} do
	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

	object = Object.normalize(activity, fetch: false)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [1]})
	\|> json_response_and_validate_schema(422) == %{"error" => "Poll's author can't vote"}

	object = Object.get_by_id(object.id)

	refute Enum.at(object.data["oneOf"], 1)["replies"]["totalItems"] == 1
	end

	test "does not allow multiple choices on a single-choice question", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "The glass is",
	poll: %{options: ["half empty", "half full"], expires_in: 20}
	})

	object = Object.normalize(activity, fetch: false)

	assert conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1]})
	\|> json_response_and_validate_schema(422) == %{"error" => "Too many choices"}

	object = Object.get_by_id(object.id)

	refute Enum.any?(object.data["oneOf"], fn %{"replies" => %{"totalItems" => total_items}} ->
	total_items == 1
	end)
	end

	test "does not allow choice index to be greater than options count", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20}
	})

	object = Object.normalize(activity, fetch: false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [2]})

	assert json_response_and_validate_schema(conn, 422) == %{"error" => "Invalid indices"}
	end

	test "returns 404 error when object is not exist", %{conn: conn} do
	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/1/votes", %{"choices" => [0]})

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end

	test "returns 404 when poll is private and not available for user", %{conn: conn} do
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(other_user, %{
	status: "Am I cute?",
	poll: %{options: ["Yes", "No"], expires_in: 20},
	visibility: "private"
	})

	object = Object.normalize(activity, fetch: false)

	conn =
	conn
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0]})

	assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
	end
	end
	end
	diff --git a/test/pleroma/workers/poll_worker_test.exs b/test/pleroma/workers/poll_worker_test.exs
	index 749df8aff..a7cbbdb83 100644
	--- a/test/pleroma/workers/poll_worker_test.exs
	+++ b/test/pleroma/workers/poll_worker_test.exs
	@@ -1,49 +1,108 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.PollWorkerTest do
	use Pleroma.DataCase
	use Oban.Testing, repo: Pleroma.Repo

	import Mock
	import Pleroma.Factory

	alias Pleroma.Workers.PollWorker

	- test "poll notification job" do
	+ test "local poll ending notification job" do
	user = insert(:user)
	question = insert(:question, user: user)
	- activity = insert(:question_activity, question: question)
	+ activity = insert(:question_activity, question: question, user: user)

	PollWorker.schedule_poll_end(activity)

	expected_job_args = %{"activity_id" => activity.id, "op" => "poll_end"}

	assert_enqueued(args: expected_job_args)

	with_mocks([
	{
	Pleroma.Web.Streamer,
	[],
	[
	stream: fn _, _ -> nil end
	]
	},
	{
	Pleroma.Web.Push,
	[],
	[
	send: fn _ -> nil end
	]
	}
	]) do
	[job] = all_enqueued(worker: PollWorker)
	PollWorker.perform(job)

	# Ensure notifications were streamed out when job executes
	assert called(Pleroma.Web.Streamer.stream(["user", "user:notification"], :_))
	assert called(Pleroma.Web.Push.send(:_))
	+
	+ # Skip refreshing polls for local activities
	+ assert activity.local
	+
	+ refute_enqueued(
	+ worker: PollWorker,
	+ args: %{"op" => "refresh", "activity_id" => activity.id}
	+ )
	+ end
	+ end
	+
	+ test "remote poll ending notification job schedules refresh" do
	+ user = insert(:user, local: false)
	+ question = insert(:question, user: user)
	+ activity = insert(:question_activity, question: question, user: user)
	+
	+ PollWorker.schedule_poll_end(activity)
	+
	+ expected_job_args = %{"activity_id" => activity.id, "op" => "poll_end"}
	+
	+ assert_enqueued(args: expected_job_args)
	+
	+ [job] = all_enqueued(worker: PollWorker)
	+ PollWorker.perform(job)
	+
	+ refute activity.local
	+
	+ assert_enqueued(
	+ worker: PollWorker,
	+ args: %{"op" => "refresh", "activity_id" => activity.id}
	+ )
	+ end
	+
	+ test "poll refresh" do
	+ user = insert(:user, local: false)
	+ question = insert(:question, user: user)
	+ activity = insert(:question_activity, question: question)
	+
	+ PollWorker.new(%{"op" => "refresh", "activity_id" => activity.id})
	+ \|> Oban.insert()
	+
	+ expected_job_args = %{"activity_id" => activity.id, "op" => "refresh"}
	+
	+ assert_enqueued(args: expected_job_args)
	+
	+ with_mocks([
	+ {
	+ Pleroma.Web.Streamer,
	+ [],
	+ [
	+ stream: fn _, _ -> nil end
	+ ]
	+ }
	+ ]) do
	+ [job] = all_enqueued(worker: PollWorker)
	+ PollWorker.perform(job)
	+
	+ # Ensure updates are streamed out
	+ assert called(Pleroma.Web.Streamer.stream(["user", "list", "public", "public:local"], :_))
	end
	end
	end
	diff --git a/test/support/factory.ex b/test/support/factory.ex
	index 8f1c6faf9..91e5805c8 100644
	--- a/test/support/factory.ex
	+++ b/test/support/factory.ex
	@@ -1,669 +1,671 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Factory do
	use ExMachina.Ecto, repo: Pleroma.Repo

	require Pleroma.Constants

	alias Pleroma.Object
	alias Pleroma.User

	@rsa_keys [
	"test/fixtures/rsa_keys/key_1.pem",
	"test/fixtures/rsa_keys/key_2.pem",
	"test/fixtures/rsa_keys/key_3.pem",
	"test/fixtures/rsa_keys/key_4.pem",
	"test/fixtures/rsa_keys/key_5.pem"
	]
	\|> Enum.map(&File.read!/1)

	def participation_factory do
	conversation = insert(:conversation)
	user = insert(:user)

	%Pleroma.Conversation.Participation{
	conversation: conversation,
	user: user,
	read: false
	}
	end

	def conversation_factory do
	%Pleroma.Conversation{
	ap_id: sequence(:ap_id, &"https://some_conversation/#{&1}")
	}
	end

	def user_factory(attrs \\ %{}) do
	pem = Enum.random(@rsa_keys)

	user = %User{
	name: sequence(:name, &"Test テスト User #{&1}"),
	email: sequence(:email, &"user#{&1}@example.com"),
	nickname: sequence(:nickname, &"nick#{&1}"),
	password_hash: Pleroma.Password.Pbkdf2.hash_pwd_salt("test"),
	bio: sequence(:bio, &"Tester Number #{&1}"),
	is_discoverable: true,
	last_digest_emailed_at: NaiveDateTime.utc_now(),
	last_refreshed_at: NaiveDateTime.utc_now(),
	notification_settings: %Pleroma.User.NotificationSetting{},
	multi_factor_authentication_settings: %Pleroma.MFA.Settings{},
	keys: pem
	}

	user
	\|> Map.put(:raw_bio, user.bio)
	\|> merge_attributes(Map.delete(attrs, :domain))
	\|> make_user_urls(attrs)
	end

	defp make_user_urls(user, attrs) do
	urls =
	if attrs[:local] == false do
	base_domain = attrs[:domain] \|\| Enum.random(["domain1.com", "domain2.com", "domain3.com"])

	ap_id = "https://#{base_domain}/users/#{user.nickname}"

	%{
	ap_id: attrs[:ap_id] \|\| ap_id,
	follower_address: attrs[:follower_address] \|\| ap_id <> "/followers",
	following_address: attrs[:following_address] \|\| ap_id <> "/following",
	featured_address: attrs[:featured_address] \|\| ap_id <> "/collections/featured",
	inbox: attrs[:inbox] \|\| "https://#{base_domain}/inbox"
	}
	else
	%{
	ap_id: attrs[:ap_id] \|\| User.ap_id(user),
	follower_address: attrs[:follower_address] \|\| User.ap_followers(user),
	following_address: attrs[:following_address] \|\| User.ap_following(user),
	featured_address: attrs[:featured_address] \|\| User.ap_featured_collection(user)
	}
	end

	Map.merge(user, urls)
	end

	def user_relationship_factory(attrs \\ %{}) do
	source = attrs[:source] \|\| insert(:user)
	target = attrs[:target] \|\| insert(:user)
	relationship_type = attrs[:relationship_type] \|\| :block

	%Pleroma.UserRelationship{
	source_id: source.id,
	target_id: target.id,
	relationship_type: relationship_type
	}
	end

	def note_factory(attrs \\ %{}) do
	text = sequence(:text, &"This is :moominmamma: note #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Note",
	"content" => text,
	"source" => text,
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"likes" => [],
	"like_count" => 0,
	"context" => "2hu",
	"summary" => "2hu",
	"tag" => ["2hu"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def attachment_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)

	data =
	attachment_data(user.ap_id, nil)
	\|> Map.put("id", Pleroma.Web.ActivityPub.Utils.generate_object_id())

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def attachment_note_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	{length, attrs} = Map.pop(attrs, :length, 1)

	data = %{
	"attachment" =>
	Stream.repeatedly(fn -> attachment_data(user.ap_id, attrs[:href]) end)
	\|> Enum.take(length)
	}

	build(:note, Map.put(attrs, :data, data))
	end

	defp attachment_data(ap_id, href) do
	href = href \|\| sequence(:href, &"#{Pleroma.Web.Endpoint.url()}/media/#{&1}.jpg")

	%{
	"url" => [
	%{
	"href" => href,
	"type" => "Link",
	"mediaType" => "image/jpeg"
	}
	],
	"name" => "some name",
	"type" => "Document",
	"actor" => ap_id,
	"mediaType" => "image/jpeg"
	}
	end

	def followers_only_note_factory(attrs \\ %{}) do
	%Pleroma.Object{data: data} = note_factory(attrs)
	%Pleroma.Object{data: Map.merge(data, %{"to" => [data["actor"] <> "/followers"]})}
	end

	def audio_factory(attrs \\ %{}) do
	text = sequence(:text, &"lain radio episode #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Audio",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"artist" => "lain",
	"title" => text,
	"album" => "lain radio",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"actor" => user.ap_id,
	"length" => 180_000
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def listen_factory do
	audio = insert(:audio)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Listen",
	"actor" => audio.data["actor"],
	"to" => audio.data["to"],
	"object" => audio.data,
	"published" => audio.data["published"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def direct_note_factory do
	user2 = insert(:user, local: false, inbox: "http://example.com/inbox")

	%Pleroma.Object{data: data} = note_factory()
	%Pleroma.Object{data: Map.merge(data, %{"to" => [user2.ap_id]})}
	end

	def article_factory do
	%Pleroma.Object{data: data} = note_factory()
	%Pleroma.Object{data: Map.merge(data, %{"type" => "Article"})}
	end

	def tombstone_factory do
	data = %{
	"type" => "Tombstone",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"formerType" => "Note",
	"deleted" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Object{
	data: data
	}
	end

	def question_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	+ closed = attrs[:closed] \|\| DateTime.utc_now() \|> DateTime.add(86_400) \|> DateTime.to_iso8601()

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"type" => "Question",
	"actor" => user.ap_id,
	"attributedTo" => user.ap_id,
	"attachment" => [],
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [user.follower_address],
	"context" => Pleroma.Web.ActivityPub.Utils.generate_context_id(),
	- "closed" => DateTime.utc_now() \|> DateTime.add(86_400) \|> DateTime.to_iso8601(),
	+ "closed" => closed,
	"content" => "Which flavor of ice cream do you prefer?",
	"oneOf" => [
	%{
	"type" => "Note",
	"name" => "chocolate",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	},
	%{
	"type" => "Note",
	"name" => "vanilla",
	"replies" => %{"totalItems" => 0, "type" => "Collection"}
	}
	]
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def direct_note_activity_factory do
	dm = insert(:direct_note)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => dm.data["actor"],
	"to" => dm.data["to"],
	"object" => dm.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => dm.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def add_activity_factory(attrs \\ %{}) do
	featured_collection_activity(attrs, "Add")
	end

	def remove_activity_factor(attrs \\ %{}) do
	featured_collection_activity(attrs, "Remove")
	end

	defp featured_collection_activity(attrs, type) do
	user = attrs[:user] \|\| insert(:user)
	note = attrs[:note] \|\| insert(:note, user: user)

	data_attrs =
	attrs
	\|> Map.get(:data_attrs, %{})
	\|> Map.put(:type, type)

	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"target" => user.featured_address,
	"object" => note.data["object"],
	"actor" => note.data["actor"],
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	def followers_only_note_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	note = insert(:followers_only_note, user: user)

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"],
	"object" => note.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	def note_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	note = attrs[:note] \|\| insert(:note, user: user)

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"],
	"object" => note.data["id"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	def article_activity_factory do
	article = insert(:article)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => article.data["actor"],
	"to" => article.data["to"],
	"object" => article.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => article.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def announce_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Announce",
	"actor" => note_activity.actor,
	"object" => note_activity.data["id"],
	"to" => [user.follower_address, note_activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => note_activity.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: user.ap_id,
	recipients: data["to"]
	}
	end

	def like_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)
	user = insert(:user)

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Like",
	"object" => object.data["id"],
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}
	\|> Map.merge(attrs[:data_attrs] \|\| %{})

	%Pleroma.Activity{
	data: data
	}
	end

	def follow_activity_factory do
	follower = insert(:user)
	followed = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data,
	actor: follower.ap_id
	}
	end

	def report_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	activity = attrs[:activity] \|\| insert(:note_activity)
	state = attrs[:state] \|\| "open"

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Flag",
	"object" => [activity.actor, activity.data["id"]],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"to" => [],
	"cc" => [activity.actor],
	"context" => activity.data["context"],
	"state" => state
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"] ++ data["cc"]
	}
	end

	def question_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	question = attrs[:question] \|\| insert(:question, user: user)

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :question, :data_attrs])

	data =
	%{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => question.data["actor"],
	"to" => question.data["to"],
	"object" => question.data["id"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => question.data["context"]
	}
	\|> Map.merge(data_attrs)

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	- recipients: data["to"]
	+ recipients: data["to"],
	+ local: user.local
	}
	\|> Map.merge(attrs)
	end

	def oauth_app_factory do
	%Pleroma.Web.OAuth.App{
	client_name: sequence(:client_name, &"Some client #{&1}"),
	redirect_uris: "https://example.com/callback",
	scopes: ["read", "write", "follow", "push", "admin"],
	website: "https://example.com",
	client_id: Ecto.UUID.generate(),
	client_secret: "aaa;/&bbb"
	}
	end

	def instance_factory do
	%Pleroma.Instances.Instance{
	host: "domain.com",
	unreachable_since: nil
	}
	end

	def oauth_token_factory(attrs \\ %{}) do
	scopes = Map.get(attrs, :scopes, ["read"])
	oauth_app = Map.get_lazy(attrs, :app, fn -> insert(:oauth_app, scopes: scopes) end)
	user = Map.get_lazy(attrs, :user, fn -> build(:user) end)

	valid_until =
	Map.get(attrs, :valid_until, NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10))

	%Pleroma.Web.OAuth.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	refresh_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	scopes: scopes,
	user: user,
	app: oauth_app,
	valid_until: valid_until
	}
	end

	def oauth_admin_token_factory(attrs \\ %{}) do
	user = Map.get_lazy(attrs, :user, fn -> build(:user, is_admin: true) end)

	scopes =
	attrs
	\|> Map.get(:scopes, ["admin"])
	\|> Kernel.++(["admin"])
	\|> Enum.uniq()

	attrs = Map.merge(attrs, %{user: user, scopes: scopes})
	oauth_token_factory(attrs)
	end

	def oauth_authorization_factory do
	%Pleroma.Web.OAuth.Authorization{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	scopes: ["read", "write", "follow", "push"],
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user),
	app: build(:oauth_app)
	}
	end

	def push_subscription_factory do
	%Pleroma.Web.Push.Subscription{
	user: build(:user),
	token: build(:oauth_token),
	endpoint: "https://example.com/example/1234",
	key_auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	key_p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA=",
	data: %{}
	}
	end

	def notification_factory do
	%Pleroma.Notification{
	user: build(:user)
	}
	end

	def scheduled_activity_factory do
	%Pleroma.ScheduledActivity{
	user: build(:user),
	scheduled_at: NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(60), :millisecond),
	params: build(:note) \|> Map.from_struct() \|> Map.get(:data)
	}
	end

	def registration_factory do
	user = insert(:user)

	%Pleroma.Registration{
	user: user,
	provider: "twitter",
	uid: "171799000",
	info: %{
	"name" => "John Doe",
	"email" => "john@doe.com",
	"nickname" => "johndoe",
	"description" => "My bio"
	}
	}
	end

	def config_factory(attrs \\ %{}) do
	%Pleroma.ConfigDB{
	key: sequence(:key, &String.to_atom("some_key_#{&1}")),
	group: :pleroma,
	value:
	sequence(
	:value,
	&%{another_key: "#{&1}somevalue", another: "#{&1}somevalue"}
	)
	}
	\|> merge_attributes(attrs)
	end

	def marker_factory do
	%Pleroma.Marker{
	user: build(:user),
	timeline: "notifications",
	lock_version: 0,
	last_read_id: "1"
	}
	end

	def mfa_token_factory do
	%Pleroma.MFA.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	authorization: build(:oauth_authorization),
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user)
	}
	end

	def filter_factory do
	%Pleroma.Filter{
	user: build(:user),
	filter_id: sequence(:filter_id, & &1),
	phrase: "cofe",
	context: ["home"]
	}
	end

	def announcement_factory(params \\ %{}) do
	data = Map.get(params, :data, %{})

	{_, params} = Map.pop(params, :data)

	%Pleroma.Announcement{
	data: Map.merge(%{"content" => "test announcement", "all_day" => false}, data)
	}
	\|> Map.merge(params)
	\|> Pleroma.Announcement.add_rendered_properties()
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 7:32 PM (1 d, 21 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798577
Default Alt Text: (684 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions