No OneTemporary
Actions

Size

619 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index b4229bd50..5f071b7e2 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,269 +1,275 @@
	# Changelog
	All notable changes to this project will be documented in this file.

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

	## [Unreleased]
	### Security
	- OStatus: eliminate the possibility of a protocol downgrade attack.
	- OStatus: prevent following locked accounts, bypassing the approval process.

	### Changed
	- Breaking: Configuration: A setting to explicitly disable the mailer was added, defaulting to true, if you are using a mailer add `config :pleroma, Pleroma.Emails.Mailer, enabled: true` to your config
	- Breaking: Configuration: `/media/` is now removed when `base_url` is configured, append `/media/` to your `base_url` config to keep the old behaviour if desired
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- Federation: Return 403 errors when trying to request pages from a user's follower/following collections if they have `hide_followers`/`hide_follows` set
	- NodeInfo: Return `skipThreadContainment` in `metadata` for the `skip_thread_containment` option
	- NodeInfo: Return `mailerEnabled` in `metadata`
	- Mastodon API: Unsubscribe followers when they unfollow a user
	- AdminAPI: Add "godmode" while fetching user statuses (i.e. admin can see private statuses)

	### Fixed
	- Not being able to pin unlisted posts
	- Objects being re-embedded to activities after being updated (e.g faved/reposted). Running 'mix pleroma.database prune_objects' again is advised.
	- Metadata rendering errors resulting in the entire page being inaccessible
	- `federation_incoming_replies_max_depth` option being ignored in certain cases
	- Federation/MediaProxy not working with instances that have wrong certificate order
	- Mastodon API: Handling of search timeouts (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API: Embedded relationships not being properly rendered in the Account entity of Status entity
	- Mastodon API: follower/following counters not being nullified, when `hide_follows`/`hide_followers` is set
	- Mastodon API: `muted` in the Status entity, using author's account to determine if the tread was muted
	- Mastodon API: Add `account_id`, `type`, `offset`, and `limit` to search API (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API, streaming: Fix filtering of notifications based on blocks/mutes/thread mutes
	- ActivityPub C2S: follower/following collection pages being inaccessible even when authentifucated if `hide_followers`/ `hide_follows` was set
	- Existing user id not being preserved on insert conflict
	- Rich Media: Parser failing when no TTL can be found by image TTL setters
	- Rich Media: The crawled URL is now spliced into the rich media data.
	- ActivityPub S2S: sharedInbox usage has been mostly aligned with the rules in the AP specification.
	- ActivityPub S2S: remote user deletions now work the same as local user deletions.
	+- ActivityPub S2S: POST requests are now signed with `(request-target)` pseudo-header.
	- Not being able to access the Mastodon FE login page on private instances
	- Invalid SemVer version generation, when the current branch does not have commits ahead of tag/checked out on a tag
	- Pleroma.Upload base_url was not automatically whitelisted by MediaProxy. Now your custom CDN or file hosting will be accessed directly as expected.
	- Report email not being sent to admins when the reporter is a remote user
	- MRF: ensure that subdomain_match calls are case-insensitive
	+- MRF: fix use of unserializable keyword lists in describe() implementations

	### Added
	+- Breaking: MRF describe API, which adds support for exposing configuration information about MRF policies to NodeInfo.
	+ Custom modules will need to be updated by adding, at the very least, `def describe, do: {:ok, %{}}` to the MRF policy modules.
	- MRF: Support for priming the mediaproxy cache (`Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`)
	- MRF: Support for excluding specific domains from Transparency.
	- MRF: Support for filtering posts based on who they mention (`Pleroma.Web.ActivityPub.MRF.MentionPolicy`)
	+- MRF: Support for filtering posts based on ActivityStreams vocabulary (`Pleroma.Web.ActivityPub.MRF.VocabularyPolicy`)
	- MRF (Simple Policy): Support for wildcard domains.
	- Support for wildcard domains in user domain blocks setting.
	- Configuration: `quarantined_instances` support wildcard domains.
	- Configuration: `federation_incoming_replies_max_depth` option
	- Mastodon API: Support for the [`tagged` filter](https://github.com/tootsuite/mastodon/pull/9755) in [`GET /api/v1/accounts/:id/statuses`](https://docs.joinmastodon.org/api/rest/accounts/#get-api-v1-accounts-id-statuses)
	- Mastodon API, streaming: Add support for passing the token in the `Sec-WebSocket-Protocol` header
	- Mastodon API, extension: Ability to reset avatar, profile banner, and background
	- Mastodon API: Add support for categories for custom emojis by reusing the group feature. <https://github.com/tootsuite/mastodon/pull/11196>
	- Mastodon API: Add support for muting/unmuting notifications
	- Mastodon API: Add support for the `blocked_by` attribute in the relationship API (`GET /api/v1/accounts/relationships`). <https://github.com/tootsuite/mastodon/pull/10373>
	- Mastodon API: Add support for the `domain_blocking` attribute in the relationship API (`GET /api/v1/accounts/relationships`).
	- Mastodon API: Add `pleroma.deactivated` to the Account entity
	- Mastodon API: added `/auth/password` endpoint for password reset with rate limit.
	- Mastodon API: /api/v1/accounts/:id/statuses now supports nicknames or user id
	- Admin API: Return users' tags when querying reports
	- Admin API: Return avatar and display name when querying users
	- Admin API: Allow querying user by ID
	- Admin API: Added support for `tuples`.
	- Admin API: Added endpoints to run mix tasks pleroma.config migrate_to_db & pleroma.config migrate_from_db
	- Added synchronization of following/followers counters for external users
	- Configuration: `enabled` option for `Pleroma.Emails.Mailer`, defaulting to `false`.
	- Configuration: Pleroma.Plugs.RateLimiter `bucket_name`, `params` options.
	+- Configuration: `user_bio_length` and `user_name_length` options.
	- Addressable lists
	- Twitter API: added rate limit for `/api/account/password_reset` endpoint.
	- ActivityPub: Add an internal service actor for fetching ActivityPub objects.
	- ActivityPub: Optional signing of ActivityPub object fetches.
	- Admin API: Endpoint for fetching latest user's statuses
	- Pleroma API: Add `/api/v1/pleroma/accounts/confirmation_resend?email=<email>` for resending account confirmation.
	- Relays: Added a task to list relay subscriptions.
	- Mix Tasks: `mix pleroma.database fix_likes_collections`
	- Federation: Remove `likes` from objects.

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

	### Removed
	- Emoji: Remove longfox emojis.
	- Remove `Reply-To` header from report emails for admins.
	- ActivityPub: The `accept_blocks` configuration setting.

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

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

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

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

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

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

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

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

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

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

	## [0.9.9] - 2019-02-22
	This is our first stable release.
	diff --git a/config/config.exs b/config/config.exs
	index bf4970314..758661120 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,549 +1,555 @@
	# .i;;;;i.
	# iYcviii;vXY:
	# .YXi .i1c.
	# .YC. . in7.
	# .vc. ...... ;1c.
	# i7, .. .;1;
	# i7, .. ... .Y1i
	# ,7v .6MMM@; .YX,
	# .7;. ..IMMMMMM1 :t7.
	# .;Y. ;$MMMMMM9. :tc.
	# vY. .. .nMMM@MMU. ;1v.
	# i7i ... .#MM@M@C. .....:71i
	# it: .... $MMM@9;.,i;;;i,;tti
	# :t7. ..... 0MMMWv.,iii:::,,;St.
	# .nC. ..... IMMMQ..,::::::,.,czX.
	# .ct: ....... .ZMMMI..,:::::::,,:76Y.
	# c2: ......,i..Y$M@t..:::::::,,..inZY
	# vov ......:ii..c$MBc..,,,,,,,,,,..iI9i
	# i9Y ......iii:..7@MA,..,,,,,,,,,....;AA:
	# iIS. ......:ii::..;@MI....,............;Ez.
	# .I9. ......:i::::...8M1..................C0z.
	# .z9; ......:i::::,.. .i:...................zWX.
	# vbv ......,i::::,,. ................. :AQY
	# c6Y. .,...,::::,,..:t0@@QY. ................ :8bi
	# :6S. ..,,...,:::,,,..EMMMMMMI. ............... .;bZ,
	# :6o, .,,,,..:::,,,..i#MMMMMM#v................. YW2.
	# .n8i ..,,,,,,,::,,,,.. tMMMMM@C:.................. .1Wn
	# 7Uc. .:::,,,,,::,,,,.. i1t;,..................... .UEi
	# 7C...::::::::::::,,,,.. .................... vSi.
	# ;1;...,,::::::,......... .................. Yz:
	# v97,......... .voC.
	# izAotX7777777777777777777777777777777777777777Y7n92:
	# .;CoIIIIIUAA666666699999ZZZZZZZZZZZZZZZZZZZZ6ov.
	#
	# !!! ATTENTION !!!
	# DO NOT EDIT THIS FILE! THIS FILE CONTAINS THE DEFAULT VALUES FOR THE CON-
	# FIGURATION! EDIT YOUR SECRET FILE (either prod.secret.exs, dev.secret.exs).
	#
	# This file is responsible for configuring your application
	# and its dependencies with the aid of the Mix.Config module.
	#
	# This configuration file is loaded before any dependency and
	# is restricted to this project.
	use Mix.Config

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

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

	config :pleroma, Pleroma.Captcha,
	enabled: false,
	seconds_valid: 60,
	method: Pleroma.Captcha.Kocaptcha

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

	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: true,
	proxy_remote: false,
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	]

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

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

	config :pleroma, Pleroma.Uploaders.MDII,
	cgi: "https://mdii.sakura.ne.jp/mdii-post.cgi",
	files: "https://mdii.sakura.ne.jp"

	config :pleroma, :emoji,
	shortcode_globs: ["/emoji/custom/*/.png"],
	pack_extensions: [".png", ".gif"],
	groups: [
	# Put groups that have higher priority than defaults here. Example in `docs/config/custom_emoji.md`
	Custom: ["/emoji/.png", "/emoji//.png"]
	],
	default_manifest: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"

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

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

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

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

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

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

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

	config :tesla, adapter: Tesla.Adapter.Hackney

	# Configures http settings, upstream proxy etc.
	config :pleroma, :http,
	proxy_url: nil,
	send_user_agent: true,
	adapter: [
	ssl_options: [
	# Workaround for remote server certificate chain issues
	partial_chain: &:hackney_connect.partial_chain/1,
	# We don't support TLS v1.3 yet
	versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]
	]
	]

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	limit: 5_000,
	remote_limit: 100_000,
	upload_limit: 16_000_000,
	avatar_upload_limit: 2_000_000,
	background_upload_limit: 4_000_000,
	banner_upload_limit: 4_000_000,
	poll_limits: %{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 365 * 24 * 60 * 60
	},
	registrations_open: true,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	federation_publisher_modules: [
	Pleroma.Web.ActivityPub.Publisher,
	Pleroma.Web.Websub,
	Pleroma.Web.Salmon
	],
	allow_relay: true,
	rewrite_policy: Pleroma.Web.ActivityPub.MRF.NoOpPolicy,
	public: true,
	quarantined_instances: [],
	managed_config: true,
	static_dir: "instance/static/",
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	],
	mrf_transparency: true,
	mrf_transparency_exclusions: [],
	autofollowed_nicknames: [],
	max_pinned_statuses: 1,
	no_attachment_links: false,
	welcome_user_nickname: nil,
	welcome_message: nil,
	max_report_comment_size: 1000,
	safe_dm_mentions: false,
	healthcheck: false,
	remote_post_retention_days: 90,
	skip_thread_containment: true,
	limit_to_local_content: :unauthenticated,
	dynamic_configuration: false,
	+ user_bio_length: 5000,
	+ user_name_length: 100,
	external_user_synchronization: true

	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.Transform.MediaProxy,
	Pleroma.HTML.Scrubber.Default
	]

	config :pleroma, :frontend_configurations,
	pleroma_fe: %{
	theme: "pleroma-dark",
	logo: "/static/logo.png",
	background: "/images/city.jpg",
	redirectRootNoLogin: "/main/all",
	redirectRootLogin: "/main/friends",
	showInstanceSpecificPanel: true,
	scopeOptionsEnabled: false,
	formattingOptionsEnabled: false,
	collapseMessageWithSubject: false,
	hidePostStats: false,
	hideUserStats: false,
	scopeCopy: true,
	subjectLineBehavior: "email",
	alwaysShowSubjectInput: true
	},
	masto_fe: %{
	showInstanceSpecificPanel: true
	}

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

	config :pleroma, :activitypub,
	unfollow_blocked: true,
	outgoing_blocks: true,
	follow_handshake_timeout: 500,
	sign_object_fetches: true

	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: [],
	accept: [],
	avatar_removal: [],
	banner_removal: []

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

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

	+config :pleroma, :mrf_vocabulary,
	+ accept: [],
	+ reject: []
	+
	config :pleroma, :rich_media,
	enabled: true,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"],
	parsers: [
	Pleroma.Web.RichMedia.Parsers.TwitterCard,
	Pleroma.Web.RichMedia.Parsers.OGP,
	Pleroma.Web.RichMedia.Parsers.OEmbed
	],
	ttl_setters: [Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl]

	config :pleroma, :media_proxy,
	enabled: false,
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	http: [
	follow_redirect: true,
	pool: :media
	]
	],
	whitelist: []

	config :pleroma, :chat, enabled: true

	config :phoenix, :format_encoders, json: Jason

	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,
	Pleroma.Web.Metadata.Providers.RelMe
	],
	unfurl_nsfw: false

	config :pleroma, :suggestions,
	enabled: false,
	third_party_engine:
	"http://vinayaka.distsn.org/cgi-bin/vinayaka-user-match-suggestions-api.cgi?{{host}}+{{user}}",
	timeout: 300_000,
	limit: 40,
	web: "https://vinayaka.distsn.org"

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

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

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

	config :pleroma, Pleroma.Web.Federator.RetryQueue,
	enabled: false,
	max_jobs: 20,
	initial_timeout: 30,
	max_retries: 5

	config :pleroma_job_queue, :queues,
	federator_incoming: 50,
	federator_outgoing: 50,
	web_push: 50,
	mailer: 10,
	transmogrifier: 20,
	scheduled_activities: 10,
	background: 5

	config :pleroma, :fetch_initial_posts,
	enabled: false,
	pages: 5

	config :auto_linker,
	opts: [
	scheme: true,
	extra: true,
	# TODO: Set to :no_scheme when it works properly
	validate_tld: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: false
	]

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

	config :esshd,
	enabled: false

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

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

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

	config :pleroma, :auth, oauth_consumer_strategies: oauth_consumer_strategies

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

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

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

	config :pleroma, :email_notifications,
	digest: %{
	active: false,
	schedule: "0 0 * * 0",
	interval: 7,
	inactivity_threshold: 7
	}

	config :pleroma, :oauth2,
	token_expires_in: 600,
	issue_new_refresh_token: true,
	clean_expired_tokens: false,
	clean_expired_tokens_interval: 86_400_000

	config :pleroma, :database, rum_enabled: false

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

	config :http_signatures,
	adapter: Pleroma.Signature

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

	# 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/config.md b/docs/config.md
	index d0247ef9c..20311db54 100644
	--- a/docs/config.md
	+++ b/docs/config.md
	@@ -1,670 +1,677 @@
	# Configuration

	This file describe the configuration, it is recommended to edit the relevant *.secret.exs file instead of the others founds in the ``config`` directory.
	If you run Pleroma with ``MIX_ENV=prod`` the file is ``prod.secret.exs``, otherwise it is ``dev.secret.exs``.

	## Pleroma.Upload
	* `uploader`: Select which `Pleroma.Uploaders` to use
	* `filters`: List of `Pleroma.Upload.Filter` to use.
	* `link_name`: When enabled Pleroma will add a `name` parameter to the url of the upload, for example `https://instance.tld/media/corndog.png?name=corndog.png`. This is needed to provide the correct filename in Content-Disposition headers when using filters like `Pleroma.Upload.Filter.Dedupe`
	* `base_url`: The base URL to access a user-uploaded file. Useful when you want to proxy the media files via another host.
	* `proxy_remote`: If you\'re using a remote uploader, Pleroma will proxy media requests instead of redirecting to it.
	* `proxy_opts`: Proxy options, see `Pleroma.ReverseProxy` documentation.

	Note: `strip_exif` has been replaced by `Pleroma.Upload.Filter.Mogrify`.

	## Pleroma.Uploaders.Local
	* `uploads`: Which directory to store the user-uploads in, relative to pleroma’s working directory

	## Pleroma.Uploaders.S3
	* `bucket`: S3 bucket name
	* `bucket_namespace`: S3 bucket namespace
	* `public_endpoint`: S3 endpoint that the user finally accesses(ex. "https://s3.dualstack.ap-northeast-1.amazonaws.com")
	* `truncated_namespace`: If you use S3 compatible service such as Digital Ocean Spaces or CDN, set folder name or "" etc.
	For example, when using CDN to S3 virtual host format, set "".
	At this time, write CNAME to CDN in public_endpoint.

	## Pleroma.Upload.Filter.Mogrify

	* `args`: List of actions for the `mogrify` command like `"strip"` or `["strip", "auto-orient", {"implode", "1"}]`.

	## Pleroma.Upload.Filter.Dedupe

	No specific configuration.

	## Pleroma.Upload.Filter.AnonymizeFilename

	This filter replaces the filename (not the path) of an upload. For complete obfuscation, add
	`Pleroma.Upload.Filter.Dedupe` before AnonymizeFilename.

	* `text`: Text to replace filenames in links. If empty, `{random}.extension` will be used. You can get the original filename extension by using `{extension}`, for example `custom-file-name.{extension}`.

	## Pleroma.Emails.Mailer
	* `adapter`: one of the mail adapters listed in [Swoosh readme](https://github.com/swoosh/swoosh#adapters), or `Swoosh.Adapters.Local` for in-memory mailbox.
	* `api_key` / `password` and / or other adapter-specific settings, per the above documentation.
	* `enabled`: Allows enable/disable send emails. Default: `false`.

	An example for Sendgrid adapter:

	```elixir
	config :pleroma, Pleroma.Emails.Mailer,
	adapter: Swoosh.Adapters.Sendgrid,
	api_key: "YOUR_API_KEY"
	```

	An example for SMTP adapter:

	```elixir
	config :pleroma, Pleroma.Emails.Mailer,
	adapter: Swoosh.Adapters.SMTP,
	relay: "smtp.gmail.com",
	username: "YOUR_USERNAME@gmail.com",
	password: "YOUR_SMTP_PASSWORD",
	port: 465,
	ssl: true,
	tls: :always,
	auth: :always
	```

	## :uri_schemes
	* `valid_schemes`: List of the scheme part that is considered valid to be an URL

	## :instance
	* `name`: The instance’s name
	* `email`: Email used to reach an Administrator/Moderator of the instance
	* `notify_email`: Email used for notifications.
	* `description`: The instance’s description, can be seen in nodeinfo and ``/api/v1/instance``
	* `limit`: Posts character limit (CW/Subject included in the counter)
	* `remote_limit`: Hard character limit beyond which remote posts will be dropped.
	* `upload_limit`: File size limit of uploads (except for avatar, background, banner)
	* `avatar_upload_limit`: File size limit of user’s profile avatars
	* `background_upload_limit`: File size limit of user’s profile backgrounds
	* `banner_upload_limit`: File size limit of user’s profile banners
	* `poll_limits`: A map with poll limits for local polls
	* `max_options`: Maximum number of options
	* `max_option_chars`: Maximum number of characters per option
	* `min_expiration`: Minimum expiration time (in seconds)
	* `max_expiration`: Maximum expiration time (in seconds)
	* `registrations_open`: Enable registrations for anyone, invitations can be enabled when false.
	* `invites_enabled`: Enable user invitations for admins (depends on `registrations_open: false`).
	* `account_activation_required`: Require users to confirm their emails before signing in.
	* `federating`: Enable federation with other instances
	* `federation_incoming_replies_max_depth`: Max. depth of reply-to activities fetching on incoming federation, to prevent out-of-memory situations while fetching very long threads. If set to `nil`, threads of any depth will be fetched. Lower this value if you experience out-of-memory crashes.
	* `federation_reachability_timeout_days`: Timeout (in days) of each external federation target being unreachable prior to pausing federating to it.
	* `allow_relay`: Enable Pleroma’s Relay, which makes it possible to follow a whole instance
	* `rewrite_policy`: Message Rewrite Policy, either one or a list. Here are the ones available by default:
	* `Pleroma.Web.ActivityPub.MRF.NoOpPolicy`: Doesn’t modify activities (default)
	* `Pleroma.Web.ActivityPub.MRF.DropPolicy`: Drops all activities. It generally doesn’t makes sense to use in production
	* `Pleroma.Web.ActivityPub.MRF.SimplePolicy`: Restrict the visibility of activities from certains instances (See ``:mrf_simple`` section)
	* `Pleroma.Web.ActivityPub.MRF.TagPolicy`: Applies policies to individual users based on tags, which can be set using pleroma-fe/admin-fe/any other app that supports Pleroma Admin API. For example it allows marking posts from individual users nsfw (sensitive)
	* `Pleroma.Web.ActivityPub.MRF.SubchainPolicy`: Selectively runs other MRF policies when messages match (see ``:mrf_subchain`` section)
	* `Pleroma.Web.ActivityPub.MRF.RejectNonPublic`: Drops posts with non-public visibility settings (See ``:mrf_rejectnonpublic`` section)
	* `Pleroma.Web.ActivityPub.MRF.EnsureRePrepended`: Rewrites posts to ensure that replies to posts with subjects do not have an identical subject and instead begin with re:.
	* `Pleroma.Web.ActivityPub.MRF.AntiLinkSpamPolicy`: Rejects posts from likely spambots by rejecting posts from new users that contain links.
	* `Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`: Crawls attachments using their MediaProxy URLs so that the MediaProxy cache is primed.
	* `Pleroma.Web.ActivityPub.MRF.MentionPolicy`: Drops posts mentioning configurable users. (see `:mrf_mention` section)
	+ * `Pleroma.Web.ActivityPub.MRF.VocabularyPolicy`: Restricts activities to a configured set of vocabulary. (see `:mrf_vocabulary` section)
	* `public`: Makes the client API in authentificated mode-only except for user-profiles. Useful for disabling the Local Timeline and The Whole Known Network.
	* `quarantined_instances`: List of ActivityPub instances where private(DMs, followers-only) activities will not be send.
	* `managed_config`: Whenether the config for pleroma-fe is configured in this config or in ``static/config.json``
	* `allowed_post_formats`: MIME-type list of formats allowed to be posted (transformed into HTML)
	* `mrf_transparency`: Make the content of your Message Rewrite Facility settings public (via nodeinfo).
	* `mrf_transparency_exclusions`: Exclude specific instance names from MRF transparency. The use of the exclusions feature will be disclosed in nodeinfo as a boolean value.
	* `scope_copy`: Copy the scope (private/unlisted/public) in replies to posts by default.
	* `subject_line_behavior`: Allows changing the default behaviour of subject lines in replies. Valid values:
	* "email": Copy and preprend re:, as in email.
	* "masto": Copy verbatim, as in Mastodon.
	* "noop": Don't copy the subject.
	* `always_show_subject_input`: When set to false, auto-hide the subject field when it's empty.
	* `extended_nickname_format`: Set to `true` to use extended local nicknames format (allows underscores/dashes). This will break federation with
	older software for theses nicknames.
	* `max_pinned_statuses`: The maximum number of pinned statuses. `0` will disable the feature.
	* `autofollowed_nicknames`: Set to nicknames of (local) users that every new user should automatically follow.
	* `no_attachment_links`: Set to true to disable automatically adding attachment link text to statuses
	* `welcome_message`: A message that will be send to a newly registered users as a direct message.
	* `welcome_user_nickname`: The nickname of the local user that sends the welcome message.
	* `max_report_comment_size`: The maximum size of the report comment (Default: `1000`)
	* `safe_dm_mentions`: If set to true, only mentions at the beginning of a post will be used to address people in direct messages. This is to prevent accidental mentioning of people when talking about them (e.g. "@friend hey i really don't like @enemy"). Default: `false`.
	* `healthcheck`: If set to true, system data will be shown on ``/api/pleroma/healthcheck``.
	* `remote_post_retention_days`: The default amount of days to retain remote posts when pruning the database.
	+* `user_bio_length`: A user bio maximum length (default: `5000`)
	+* `user_name_length`: A user name maximum length (default: `100`)
	* `skip_thread_containment`: Skip filter out broken threads. The default is `false`.
	* `limit_to_local_content`: Limit unauthenticated users to search for local statutes and users only. Possible values: `:unauthenticated`, `:all` and `false`. The default is `:unauthenticated`.
	* `dynamic_configuration`: Allow transferring configuration to DB with the subsequent customization from Admin api.
	* `external_user_synchronization`: Enabling following/followers counters synchronization for external users.



	## :logger
	* `backends`: `:console` is used to send logs to stdout, `{ExSyslogger, :ex_syslogger}` to log to syslog, and `Quack.Logger` to log to Slack

	An example to enable ONLY ExSyslogger (f/ex in ``prod.secret.exs``) with info and debug suppressed:
	```elixir
	config :logger,
	backends: [{ExSyslogger, :ex_syslogger}]

	config :logger, :ex_syslogger,
	level: :warn
	```

	Another example, keeping console output and adding the pid to syslog output:
	```elixir
	config :logger,
	backends: [:console, {ExSyslogger, :ex_syslogger}]

	config :logger, :ex_syslogger,
	level: :warn,
	option: [:pid, :ndelay]
	```

	See: [logger’s documentation](https://hexdocs.pm/logger/Logger.html) and [ex_syslogger’s documentation](https://hexdocs.pm/ex_syslogger/)

	An example of logging info to local syslog, but warn to a Slack channel:
	```elixir
	config :logger,
	backends: [ {ExSyslogger, :ex_syslogger}, Quack.Logger ],
	level: :info

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

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

	See the [Quack Github](https://github.com/azohra/quack) for more details

	## :frontend_configurations

	This can be used to configure a keyword list that keeps the configuration data for any kind of frontend. By default, settings for `pleroma_fe` and `masto_fe` are configured.

	Frontends can access these settings at `/api/pleroma/frontend_configurations`

	To add your own configuration for PleromaFE, use it like this:

	```elixir
	config :pleroma, :frontend_configurations,
	pleroma_fe: %{
	theme: "pleroma-dark",
	# ... see /priv/static/static/config.json for the available keys.
	},
	masto_fe: %{
	showInstanceSpecificPanel: true
	}
	```

	These settings need to be complete, they will override the defaults.

	NOTE: for versions < 1.0, you need to set [`:fe`](#fe) to false, as shown a few lines below.

	## :fe
	__THIS IS DEPRECATED__

	If you are using this method, please change it to the [`frontend_configurations`](#frontend_configurations) method.
	Please set this option to false in your config like this:

	```elixir
	config :pleroma, :fe, false
	```

	This section is used to configure Pleroma-FE, unless ``:managed_config`` in ``:instance`` is set to false.

	* `theme`: Which theme to use, they are defined in ``styles.json``
	* `logo`: URL of the logo, defaults to Pleroma’s logo
	* `logo_mask`: Whether to use only the logo's shape as a mask (true) or as a regular image (false)
	* `logo_margin`: What margin to use around the logo
	* `background`: URL of the background, unless viewing a user profile with a background that is set
	* `redirect_root_no_login`: relative URL which indicates where to redirect when a user isn’t logged in.
	* `redirect_root_login`: relative URL which indicates where to redirect when a user is logged in.
	* `show_instance_panel`: Whenether to show the instance’s specific panel.
	* `scope_options_enabled`: Enable setting an notice visibility and subject/CW when posting
	* `formatting_options_enabled`: Enable setting a formatting different than plain-text (ie. HTML, Markdown) when posting, relates to ``:instance, allowed_post_formats``
	* `collapse_message_with_subjects`: When a message has a subject(aka Content Warning), collapse it by default
	* `hide_post_stats`: Hide notices statistics(repeats, favorites, …)
	* `hide_user_stats`: Hide profile statistics(posts, posts per day, followers, followings, …)

	## :assets

	This section configures assets to be used with various frontends. Currently the only option
	relates to mascots on the mastodon frontend

	* `mascots`: KeywordList of mascots, each element __MUST__ contain both a `url` and a
	`mime_type` key.
	* `default_mascot`: An element from `mascots` - This will be used as the default mascot
	on MastoFE (default: `:pleroma_fox_tan`)

	## :mrf_simple
	* `media_removal`: List of instances to remove medias from
	* `media_nsfw`: List of instances to put medias as NSFW(sensitive) from
	* `federated_timeline_removal`: List of instances to remove from Federated (aka The Whole Known Network) Timeline
	* `reject`: List of instances to reject any activities from
	* `accept`: List of instances to accept any activities from
	* `report_removal`: List of instances to reject reports from
	* `avatar_removal`: List of instances to strip avatars from
	* `banner_removal`: List of instances to strip banners from

	## :mrf_subchain
	This policy processes messages through an alternate pipeline when a given message matches certain criteria.
	All criteria are configured as a map of regular expressions to lists of policy modules.

	* `match_actor`: Matches a series of regular expressions against the actor field.

	Example:

	```
	config :pleroma, :mrf_subchain,
	match_actor: %{
	~r/https:\/\/example.com/s => [Pleroma.Web.ActivityPub.MRF.DropPolicy]
	}
	```

	## :mrf_rejectnonpublic
	* `allow_followersonly`: whether to allow followers-only posts
	* `allow_direct`: whether to allow direct messages

	## :mrf_hellthread
	* `delist_threshold`: Number of mentioned users after which the message gets delisted (the message can still be seen, but it will not show up in public timelines and mentioned users won't get notifications about it). Set to 0 to disable.
	* `reject_threshold`: Number of mentioned users after which the messaged gets rejected. Set to 0 to disable.

	## :mrf_keyword
	* `reject`: A list of patterns which result in message being rejected, each pattern can be a string or a [regular expression](https://hexdocs.pm/elixir/Regex.html)
	* `federated_timeline_removal`: A list of patterns which result in message being removed from federated timelines (a.k.a unlisted), each pattern can be a string or a [regular expression](https://hexdocs.pm/elixir/Regex.html)
	* `replace`: A list of tuples containing `{pattern, replacement}`, `pattern` can be a string or a [regular expression](https://hexdocs.pm/elixir/Regex.html)

	## :mrf_mention
	* `actors`: A list of actors, for which to drop any posts mentioning.

	+## :mrf_vocabulary
	+* `accept`: A list of ActivityStreams terms to accept. If empty, all supported messages are accepted.
	+* `reject`: A list of ActivityStreams terms to reject. If empty, no messages are rejected.
	+
	## :media_proxy
	* `enabled`: Enables proxying of remote media to the instance’s proxy
	* `base_url`: The base URL to access a user-uploaded file. Useful when you want to proxy the media files via another host/CDN fronts.
	* `proxy_opts`: All options defined in `Pleroma.ReverseProxy` documentation, defaults to `[max_body_length: (25*1_048_576)]`.
	* `whitelist`: List of domains to bypass the mediaproxy

	## :gopher
	* `enabled`: Enables the gopher interface
	* `ip`: IP address to bind to
	* `port`: Port to bind to
	* `dstport`: Port advertised in urls (optional, defaults to `port`)

	## Pleroma.Web.Endpoint
	`Phoenix` endpoint configuration, all configuration options can be viewed [here](https://hexdocs.pm/phoenix/Phoenix.Endpoint.html#module-dynamic-configuration), only common options are listed here
	* `http` - a list containing http protocol configuration, all configuration options can be viewed [here](https://hexdocs.pm/plug_cowboy/Plug.Cowboy.html#module-options), only common options are listed here. For deployment using docker, you need to set this to `[ip: {0,0,0,0}, port: 4000]` to make pleroma accessible from other containers (such as your nginx server).
	- `ip` - a tuple consisting of 4 integers
	- `port`
	* `url` - a list containing the configuration for generating urls, accepts
	- `host` - the host without the scheme and a post (e.g `example.com`, not `https://example.com:2020`)
	- `scheme` - e.g `http`, `https`
	- `port`
	- `path`
	* `extra_cookie_attrs` - a list of `Key=Value` strings to be added as non-standard cookie attributes. Defaults to `["SameSite=Lax"]`. See the [SameSite article](https://www.owasp.org/index.php/SameSite) on OWASP for more info.



	Important note: if you modify anything inside these lists, default `config.exs` values will be overwritten, which may result in breakage, to make sure this does not happen please copy the default value for the list from `config.exs` and modify/add only what you need

	Example:
	```elixir
	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "example.com", port: 2020, scheme: "https"],
	http: [
	# start copied from config.exs
	dispatch: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, websocket_config}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	# end copied from config.exs
	],
	port: 8080,
	ip: {127, 0, 0, 1}
	]
	```

	This will make Pleroma listen on `127.0.0.1` port `8080` and generate urls starting with `https://example.com:2020`

	## :activitypub
	* ``unfollow_blocked``: Whether blocks result in people getting unfollowed
	* ``outgoing_blocks``: Whether to federate blocks to other instances
	* ``deny_follow_blocked``: Whether to disallow following an account that has blocked the user in question
	* ``sign_object_fetches``: Sign object fetches with HTTP signatures

	## :http_security
	* ``enabled``: Whether the managed content security policy is enabled
	* ``sts``: Whether to additionally send a `Strict-Transport-Security` header
	* ``sts_max_age``: The maximum age for the `Strict-Transport-Security` header if sent
	* ``ct_max_age``: The maximum age for the `Expect-CT` header if sent
	* ``referrer_policy``: The referrer policy to use, either `"same-origin"` or `"no-referrer"`
	* ``report_uri``: Adds the specified url to `report-uri` and `report-to` group in CSP header.

	## :mrf_user_allowlist

	The keys in this section are the domain names that the policy should apply to.
	Each key should be assigned a list of users that should be allowed through by
	their ActivityPub ID.

	An example:

	```elixir
	config :pleroma, :mrf_user_allowlist,
	"example.org": ["https://example.org/users/admin"]
	```

	## :web_push_encryption, :vapid_details

	Web Push Notifications configuration. You can use the mix task `mix web_push.gen.keypair` to generate it.

	* ``subject``: a mailto link for the administrative contact. It’s best if this email is not a personal email address, but rather a group email so that if a person leaves an organization, is unavailable for an extended period, or otherwise can’t respond, someone else on the list can.
	* ``public_key``: VAPID public key
	* ``private_key``: VAPID private key

	## Pleroma.Captcha
	* `enabled`: Whether the captcha should be shown on registration
	* `method`: The method/service to use for captcha
	* `seconds_valid`: The time in seconds for which the captcha is valid

	### Pleroma.Captcha.Kocaptcha
	Kocaptcha is a very simple captcha service with a single API endpoint,
	the source code is here: https://github.com/koto-bank/kocaptcha. The default endpoint
	`https://captcha.kotobank.ch` is hosted by the developer.

	* `endpoint`: the kocaptcha endpoint to use

	## :admin_token

	Allows to set a token that can be used to authenticate with the admin api without using an actual user by giving it as the 'admin_token' parameter. Example:

	```elixir
	config :pleroma, :admin_token, "somerandomtoken"
	```

	You can then do

	```sh
	curl "http://localhost:4000/api/pleroma/admin/invite_token?admin_token=somerandomtoken"
	```

	## :pleroma_job_queue

	[Pleroma Job Queue](https://git.pleroma.social/pleroma/pleroma_job_queue) configuration: a list of queues with maximum concurrent jobs.

	Pleroma has the following queues:

	* `federator_outgoing` - Outgoing federation
	* `federator_incoming` - Incoming federation
	* `mailer` - Email sender, see [`Pleroma.Emails.Mailer`](#pleroma-emails-mailer)
	* `transmogrifier` - Transmogrifier
	* `web_push` - Web push notifications
	* `scheduled_activities` - Scheduled activities, see [`Pleroma.ScheduledActivities`](#pleromascheduledactivity)

	Example:

	```elixir
	config :pleroma_job_queue, :queues,
	federator_incoming: 50,
	federator_outgoing: 50
	```

	This config contains two queues: `federator_incoming` and `federator_outgoing`. Both have the `max_jobs` set to `50`.

	## Pleroma.Web.Federator.RetryQueue

	* `enabled`: If set to `true`, failed federation jobs will be retried
	* `max_jobs`: The maximum amount of parallel federation jobs running at the same time.
	* `initial_timeout`: The initial timeout in seconds
	* `max_retries`: The maximum number of times a federation job is retried

	## Pleroma.Web.Metadata
	* `providers`: a list of metadata providers to enable. Providers available:
	* Pleroma.Web.Metadata.Providers.OpenGraph
	* Pleroma.Web.Metadata.Providers.TwitterCard
	* Pleroma.Web.Metadata.Providers.RelMe - add links from user bio with rel=me into the `<header>` as `<link rel=me>`
	* `unfurl_nsfw`: If set to `true` nsfw attachments will be shown in previews

	## :rich_media
	* `enabled`: if enabled the instance will parse metadata from attached links to generate link previews
	* `ignore_hosts`: list of hosts which will be ignored by the metadata parser. For example `["accounts.google.com", "xss.website"]`, defaults to `[]`.
	* `ignore_tld`: list TLDs (top-level domains) which will ignore for parse metadata. default is ["local", "localdomain", "lan"]
	* `parsers`: list of Rich Media parsers

	## :fetch_initial_posts
	* `enabled`: if enabled, when a new user is federated with, fetch some of their latest posts
	* `pages`: the amount of pages to fetch

	## :hackney_pools

	Advanced. Tweaks Hackney (http client) connections pools.

	There's three pools used:

	* `:federation` for the federation jobs.
	You may want this pool max_connections to be at least equal to the number of federator jobs + retry queue jobs.
	* `:media` for rich media, media proxy
	* `:upload` for uploaded media (if using a remote uploader and `proxy_remote: true`)

	For each pool, the options are:

	* `max_connections` - how much connections a pool can hold
	* `timeout` - retention duration for connections

	## :auto_linker

	Configuration for the `auto_linker` library:

	* `class: "auto-linker"` - specify the class to be added to the generated link. false to clear
	* `rel: "noopener noreferrer"` - override the rel attribute. false to clear
	* `new_window: true` - set to false to remove `target='_blank'` attribute
	* `scheme: false` - Set to true to link urls with schema `http://google.com`
	* `truncate: false` - Set to a number to truncate urls longer then the number. Truncated urls will end in `..`
	* `strip_prefix: true` - Strip the scheme prefix
	* `extra: false` - link urls with rarely used schemes (magnet, ipfs, irc, etc.)

	Example:

	```elixir
	config :auto_linker,
	opts: [
	scheme: true,
	extra: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: false
	]
	```

	## Pleroma.ScheduledActivity

	* `daily_user_limit`: the number of scheduled activities a user is allowed to create in a single day (Default: `25`)
	* `total_user_limit`: the number of scheduled activities a user is allowed to create in total (Default: `300`)
	* `enabled`: whether scheduled activities are sent to the job queue to be executed

	## Pleroma.Web.Auth.Authenticator

	* `Pleroma.Web.Auth.PleromaAuthenticator`: default database authenticator
	* `Pleroma.Web.Auth.LDAPAuthenticator`: LDAP authentication

	## :ldap

	Use LDAP for user authentication. When a user logs in to the Pleroma
	instance, the name and password will be verified by trying to authenticate
	(bind) to an LDAP server. If a user exists in the LDAP directory but there
	is no account with the same name yet on the Pleroma instance then a new
	Pleroma account will be created with the same name as the LDAP user name.

	* `enabled`: enables LDAP authentication
	* `host`: LDAP server hostname
	* `port`: LDAP port, e.g. 389 or 636
	* `ssl`: true to use SSL, usually implies the port 636
	* `sslopts`: additional SSL options
	* `tls`: true to start TLS, usually implies the port 389
	* `tlsopts`: additional TLS options
	* `base`: LDAP base, e.g. "dc=example,dc=com"
	* `uid`: LDAP attribute name to authenticate the user, e.g. when "cn", the filter will be "cn=username,base"

	## BBS / SSH access

	To enable simple command line interface accessible over ssh, add a setting like this to your configuration file:

	```exs
	app_dir = File.cwd!
	priv_dir = Path.join([app_dir, "priv/ssh_keys"])

	config :esshd,
	enabled: true,
	priv_dir: priv_dir,
	handler: "Pleroma.BBS.Handler",
	port: 10_022,
	password_authenticator: "Pleroma.BBS.Authenticator"
	```

	Feel free to adjust the priv_dir and port number. Then you will have to create the key for the keys (in the example `priv/ssh_keys`) and create the host keys with `ssh-keygen -m PEM -N "" -b 2048 -t rsa -f ssh_host_rsa_key`. After restarting, you should be able to connect to your Pleroma instance with `ssh username@server -p $PORT`

	## :auth

	* `Pleroma.Web.Auth.PleromaAuthenticator`: default database authenticator
	* `Pleroma.Web.Auth.LDAPAuthenticator`: LDAP authentication

	Authentication / authorization settings.

	* `auth_template`: authentication form template. By default it's `show.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/show.html.eex`.
	* `oauth_consumer_template`: OAuth consumer mode authentication form template. By default it's `consumer.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex`.
	* `oauth_consumer_strategies`: the list of enabled OAuth consumer strategies; by default it's set by `OAUTH_CONSUMER_STRATEGIES` environment variable. Each entry in this space-delimited string should be of format `<strategy>` or `<strategy>:<dependency>` (e.g. `twitter` or `keycloak:ueberauth_keycloak_strategy` in case dependency is named differently than `ueberauth_<strategy>`).

	## :email_notifications

	Email notifications settings.

	- digest - emails of "what you've missed" for users who have been
	inactive for a while.
	- active: globally enable or disable digest emails
	- schedule: When to send digest email, in [crontab format](https://en.wikipedia.org/wiki/Cron).
	"0 0 * * 0" is the default, meaning "once a week at midnight on Sunday morning"
	- interval: Minimum interval between digest emails to one user
	- inactivity_threshold: Minimum user inactivity threshold

	## OAuth consumer mode

	OAuth consumer mode allows sign in / sign up via external OAuth providers (e.g. Twitter, Facebook, Google, Microsoft, etc.).
	Implementation is based on Ueberauth; see the list of [available strategies](https://github.com/ueberauth/ueberauth/wiki/List-of-Strategies).

	Note: each strategy is shipped as a separate dependency; in order to get the strategies, run `OAUTH_CONSUMER_STRATEGIES="..." mix deps.get`,
	e.g. `OAUTH_CONSUMER_STRATEGIES="twitter facebook google microsoft" mix deps.get`.
	The server should also be started with `OAUTH_CONSUMER_STRATEGIES="..." mix phx.server` in case you enable any strategies.

	Note: each strategy requires separate setup (on external provider side and Pleroma side). Below are the guidelines on setting up most popular strategies.

	Note: make sure that `"SameSite=Lax"` is set in `extra_cookie_attrs` when you have this feature enabled. OAuth consumer mode will not work with `"SameSite=Strict"`

	* For Twitter, [register an app](https://developer.twitter.com/en/apps), configure callback URL to https://<your_host>/oauth/twitter/callback

	* For Facebook, [register an app](https://developers.facebook.com/apps), configure callback URL to https://<your_host>/oauth/facebook/callback, enable Facebook Login service at https://developers.facebook.com/apps/<app_id>/fb-login/settings/

	* For Google, [register an app](https://console.developers.google.com), configure callback URL to https://<your_host>/oauth/google/callback

	* For Microsoft, [register an app](https://portal.azure.com), configure callback URL to https://<your_host>/oauth/microsoft/callback

	Once the app is configured on external OAuth provider side, add app's credentials and strategy-specific settings (if any — e.g. see Microsoft below) to `config/prod.secret.exs`,
	per strategy's documentation (e.g. [ueberauth_twitter](https://github.com/ueberauth/ueberauth_twitter)). Example config basing on environment variables:

	```elixir
	# Twitter
	config :ueberauth, Ueberauth.Strategy.Twitter.OAuth,
	consumer_key: System.get_env("TWITTER_CONSUMER_KEY"),
	consumer_secret: System.get_env("TWITTER_CONSUMER_SECRET")

	# Facebook
	config :ueberauth, Ueberauth.Strategy.Facebook.OAuth,
	client_id: System.get_env("FACEBOOK_APP_ID"),
	client_secret: System.get_env("FACEBOOK_APP_SECRET"),
	redirect_uri: System.get_env("FACEBOOK_REDIRECT_URI")

	# Google
	config :ueberauth, Ueberauth.Strategy.Google.OAuth,
	client_id: System.get_env("GOOGLE_CLIENT_ID"),
	client_secret: System.get_env("GOOGLE_CLIENT_SECRET"),
	redirect_uri: System.get_env("GOOGLE_REDIRECT_URI")

	# Microsoft
	config :ueberauth, Ueberauth.Strategy.Microsoft.OAuth,
	client_id: System.get_env("MICROSOFT_CLIENT_ID"),
	client_secret: System.get_env("MICROSOFT_CLIENT_SECRET")

	config :ueberauth, Ueberauth,
	providers: [
	microsoft: {Ueberauth.Strategy.Microsoft, [callback_params: []]}
	]

	# Keycloak
	# Note: make sure to add `keycloak:ueberauth_keycloak_strategy` entry to `OAUTH_CONSUMER_STRATEGIES` environment variable
	keycloak_url = "https://publicly-reachable-keycloak-instance.org:8080"

	config :ueberauth, Ueberauth.Strategy.Keycloak.OAuth,
	client_id: System.get_env("KEYCLOAK_CLIENT_ID"),
	client_secret: System.get_env("KEYCLOAK_CLIENT_SECRET"),
	site: keycloak_url,
	authorize_url: "#{keycloak_url}/auth/realms/master/protocol/openid-connect/auth",
	token_url: "#{keycloak_url}/auth/realms/master/protocol/openid-connect/token",
	userinfo_url: "#{keycloak_url}/auth/realms/master/protocol/openid-connect/userinfo",
	token_method: :post

	config :ueberauth, Ueberauth,
	providers: [
	keycloak: {Ueberauth.Strategy.Keycloak, [uid_field: :email]}
	]
	```

	## OAuth 2.0 provider - :oauth2

	Configure OAuth 2 provider capabilities:

	* `token_expires_in` - The lifetime in seconds of the access token.
	* `issue_new_refresh_token` - Keeps old refresh token or generate new refresh token when to obtain an access token.
	* `clean_expired_tokens` - Enable a background job to clean expired oauth tokens. Defaults to `false`.
	* `clean_expired_tokens_interval` - Interval to run the job to clean expired tokens. Defaults to `86_400_000` (24 hours).

	## :emoji
	* `shortcode_globs`: Location of custom emoji files. `` can be used as a wildcard. Example `["/emoji/custom//.png"]`
	* `pack_extensions`: A list of file extensions for emojis, when no emoji.txt for a pack is present. Example `[".png", ".gif"]`
	* `groups`: Emojis are ordered in groups (tags). This is an array of key-value pairs where the key is the groupname and the value the location or array of locations. `` can be used as a wildcard. Example `[Custom: ["/emoji/.png", "/emoji/custom/*.png"]]`
	* `default_manifest`: Location of the JSON-manifest. This manifest contains information about the emoji-packs you can download. Currently only one manifest can be added (no arrays).

	## Database options

	### RUM indexing for full text search
	* `rum_enabled`: If RUM indexes should be used. Defaults to `false`.

	RUM indexes are an alternative indexing scheme that is not included in PostgreSQL by default. While they may eventually be mainlined, for now they have to be installed as a PostgreSQL extension from https://github.com/postgrespro/rum.

	Their advantage over the standard GIN indexes is that they allow efficient ordering of search results by timestamp, which makes search queries a lot faster on larger servers, by one or two orders of magnitude. They take up around 3 times as much space as GIN indexes.

	To enable them, both the `rum_enabled` flag has to be set and the following special migration has to be run:

	`mix ecto.migrate --migrations-path priv/repo/optional_migrations/rum_indexing/`

	This will probably take a long time.

	## :rate_limit

	A keyword list of rate limiters where a key is a limiter name and value is the limiter configuration. The basic configuration is a tuple where:

	* The first element: `scale` (Integer). The time scale in milliseconds.
	* The second element: `limit` (Integer). How many requests to limit in the time scale provided.

	It is also possible to have different limits for unauthenticated and authenticated users: the keyword value must be a list of two tuples where the first one is a config for unauthenticated users and the second one is for authenticated.

	See [`Pleroma.Plugs.RateLimiter`](Pleroma.Plugs.RateLimiter.html) documentation for examples.

	Supported rate limiters:

	* `:search` for the search requests (account & status search etc.)
	* `:app_account_creation` for registering user accounts from the same IP address
	* `:relations_actions` for actions on relations with all users (follow, unfollow)
	* `:relation_id_action` for actions on relation with a specific user (follow, unfollow)
	* `:statuses_actions` for create / delete / fav / unfav / reblog / unreblog actions on any statuses
	* `:status_id_action` for fav / unfav or reblog / unreblog actions on the same status by the same user
	diff --git a/lib/mix/tasks/pleroma/benchmark.ex b/lib/mix/tasks/pleroma/benchmark.ex
	index 5222cce80..4cc634727 100644
	--- a/lib/mix/tasks/pleroma/benchmark.ex
	+++ b/lib/mix/tasks/pleroma/benchmark.ex
	@@ -1,29 +1,73 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Benchmark do
	import Mix.Pleroma
	use Mix.Task

	def run(["search"]) do
	start_pleroma()

	Benchee.run(%{
	"search" => fn ->
	Pleroma.Activity.search(nil, "cofe")
	end
	})
	end

	def run(["tag"]) do
	start_pleroma()

	Benchee.run(%{
	"tag" => fn ->
	%{"type" => "Create", "tag" => "cofe"}
	\|> Pleroma.Web.ActivityPub.ActivityPub.fetch_public_activities()
	end
	})
	end
	+
	+ def run(["render_timeline", nickname]) do
	+ start_pleroma()
	+ user = Pleroma.User.get_by_nickname(nickname)
	+
	+ activities =
	+ %{}
	+ \|> Map.put("type", ["Create", "Announce"])
	+ \|> Map.put("blocking_user", user)
	+ \|> Map.put("muting_user", user)
	+ \|> Map.put("user", user)
	+ \|> Map.put("limit", 80)
	+ \|> Pleroma.Web.ActivityPub.ActivityPub.fetch_public_activities()
	+ \|> Enum.reverse()
	+
	+ inputs = %{
	+ "One activity" => Enum.take_random(activities, 1),
	+ "Ten activities" => Enum.take_random(activities, 10),
	+ "Twenty activities" => Enum.take_random(activities, 20),
	+ "Forty activities" => Enum.take_random(activities, 40),
	+ "Eighty activities" => Enum.take_random(activities, 80)
	+ }
	+
	+ Benchee.run(
	+ %{
	+ "Parallel rendering" => fn activities ->
	+ Pleroma.Web.MastodonAPI.StatusView.render("index.json", %{
	+ activities: activities,
	+ for: user,
	+ as: :activity
	+ })
	+ end,
	+ "Standart rendering" => fn activities ->
	+ Pleroma.Web.MastodonAPI.StatusView.render("index.json", %{
	+ activities: activities,
	+ for: user,
	+ as: :activity,
	+ parallel: false
	+ })
	+ end
	+ },
	+ inputs: inputs
	+ )
	+ end
	end
	diff --git a/lib/pleroma/activity.ex b/lib/pleroma/activity.ex
	index 46552c7be..baf1e7722 100644
	--- a/lib/pleroma/activity.ex
	+++ b/lib/pleroma/activity.ex
	@@ -1,348 +1,371 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ThreadMute
	alias Pleroma.User

	import Ecto.Changeset
	import Ecto.Query

	@type t :: %__MODULE__{}
	@type actor :: String.t()

	@primary_key {:id, Pleroma.FlakeId, autogenerate: true}

	# https://github.com/tootsuite/mastodon/blob/master/app/models/notification.rb#L19
	@mastodon_notification_types %{
	"Create" => "mention",
	"Follow" => "follow",
	"Announce" => "reblog",
	"Like" => "favourite"
	}

	@mastodon_to_ap_notification_types for {k, v} <- @mastodon_notification_types,
	into: %{},
	do: {v, k}

	schema "activities" do
	field(:data, :map)
	field(:local, :boolean, default: true)
	field(:actor, :string)
	field(:recipients, {:array, :string}, default: [])
	field(:thread_muted?, :boolean, virtual: true)
	# This is a fake relation, do not use outside of with_preloaded_bookmark/get_bookmark
	has_one(:bookmark, Bookmark)
	has_many(:notifications, Notification, on_delete: :delete_all)

	# Attention: this is a fake relation, don't try to preload it blindly and expect it to work!
	# The foreign key is embedded in a jsonb field.
	#
	# To use it, you probably want to do an inner join and a preload:
	#
	# ```
	# \|> join(:inner, [activity], o in Object,
	# on: fragment("(?->>'id') = COALESCE((?)->'object'->> 'id', (?)->>'object')",
	# o.data, activity.data, activity.data))
	# \|> preload([activity, object], [object: object])
	# ```
	#
	# As a convenience, Activity.with_preloaded_object() sets up an inner join and preload for the
	# typical case.
	has_one(:object, Object, on_delete: :nothing, foreign_key: :id)

	timestamps()
	end

	def with_joined_object(query) do
	join(query, :inner, [activity], o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	as: :object
	)
	end

	def with_preloaded_object(query) do
	query
	\|> has_named_binding?(:object)
	\|> if(do: query, else: with_joined_object(query))
	\|> preload([activity, object: object], object: object)
	end

	def with_preloaded_bookmark(query, %User{} = user) do
	from([a] in query,
	left_join: b in Bookmark,
	on: b.user_id == ^user.id and b.activity_id == a.id,
	preload: [bookmark: b]
	)
	end

	def with_preloaded_bookmark(query, _), do: query

	def with_set_thread_muted_field(query, %User{} = user) do
	from([a] in query,
	left_join: tm in ThreadMute,
	on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data),
	select: %Activity{a \| thread_muted?: not is_nil(tm.id)}
	)
	end

	def with_set_thread_muted_field(query, _), do: query

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

	def get_bookmark(%Activity{} = activity, %User{} = user) do
	if Ecto.assoc_loaded?(activity.bookmark) do
	activity.bookmark
	else
	Bookmark.get(user.id, activity.id)
	end
	end

	def get_bookmark(_, _), do: nil

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data, :recipients])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :activities_unique_apid_index)
	end

	def get_by_ap_id_with_object(ap_id) do
	Repo.one(
	from(
	activity in Activity,
	where: fragment("(?)->>'id' = ?", activity.data, ^to_string(ap_id)),
	left_join: o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	preload: [object: o]
	)
	)
	end

	def get_by_id(id) do
	Activity
	\|> where([a], a.id == ^id)
	\|> restrict_deactivated_users()
	\|> Repo.one()
	end

	def get_by_id_with_object(id) do
	from(activity in Activity,
	where: activity.id == ^id,
	inner_join: o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	preload: [object: o]
	)
	\|> Repo.one()
	end

	def by_object_ap_id(ap_id) do
	from(
	activity in Activity,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^to_string(ap_id)
	)
	)
	end

	def create_by_object_ap_id(ap_ids) when is_list(ap_ids) do
	from(
	activity in Activity,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ANY(?)",
	activity.data,
	activity.data,
	^ap_ids
	),
	where: fragment("(?)->>'type' = 'Create'", activity.data)
	)
	end

	def create_by_object_ap_id(ap_id) when is_binary(ap_id) do
	from(
	activity in Activity,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^to_string(ap_id)
	),
	where: fragment("(?)->>'type' = 'Create'", activity.data)
	)
	end

	def create_by_object_ap_id(_), do: nil

	def get_all_create_by_object_ap_id(ap_id) do
	Repo.all(create_by_object_ap_id(ap_id))
	end

	def get_create_by_object_ap_id(ap_id) when is_binary(ap_id) do
	create_by_object_ap_id(ap_id)
	\|> restrict_deactivated_users()
	\|> Repo.one()
	end

	def get_create_by_object_ap_id(_), do: nil

	+ def create_by_object_ap_id_with_object(ap_ids) when is_list(ap_ids) do
	+ from(
	+ activity in Activity,
	+ where:
	+ fragment(
	+ "coalesce((?)->'object'->>'id', (?)->>'object') = ANY(?)",
	+ activity.data,
	+ activity.data,
	+ ^ap_ids
	+ ),
	+ where: fragment("(?)->>'type' = 'Create'", activity.data),
	+ inner_join: o in Object,
	+ on:
	+ fragment(
	+ "(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	+ o.data,
	+ activity.data,
	+ activity.data
	+ ),
	+ preload: [object: o]
	+ )
	+ end
	+
	def create_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
	from(
	activity in Activity,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^to_string(ap_id)
	),
	where: fragment("(?)->>'type' = 'Create'", activity.data),
	inner_join: o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	preload: [object: o]
	)
	end

	def create_by_object_ap_id_with_object(_), do: nil

	def get_create_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
	ap_id
	\|> create_by_object_ap_id_with_object()
	\|> Repo.one()
	end

	def get_create_by_object_ap_id_with_object(_), do: nil

	defp get_in_reply_to_activity_from_object(%Object{data: %{"inReplyTo" => ap_id}}) do
	get_create_by_object_ap_id_with_object(ap_id)
	end

	defp get_in_reply_to_activity_from_object(_), do: nil

	- def get_in_reply_to_activity(%Activity{data: %{"object" => object}}) do
	- get_in_reply_to_activity_from_object(Object.normalize(object))
	+ def get_in_reply_to_activity(%Activity{} = activity) do
	+ get_in_reply_to_activity_from_object(Object.normalize(activity))
	end

	def normalize(obj) when is_map(obj), do: get_by_ap_id_with_object(obj["id"])
	def normalize(ap_id) when is_binary(ap_id), do: get_by_ap_id_with_object(ap_id)
	def normalize(_), do: nil

	def delete_by_ap_id(id) when is_binary(id) do
	by_object_ap_id(id)
	\|> select([u], u)
	\|> Repo.delete_all()
	\|> elem(1)
	\|> Enum.find(fn
	%{data: %{"type" => "Create", "object" => ap_id}} when is_binary(ap_id) -> ap_id == id
	%{data: %{"type" => "Create", "object" => %{"id" => ap_id}}} -> ap_id == id
	_ -> nil
	end)
	end

	def delete_by_ap_id(_), do: nil

	for {ap_type, type} <- @mastodon_notification_types do
	def mastodon_notification_type(%Activity{data: %{"type" => unquote(ap_type)}}),
	do: unquote(type)
	end

	def mastodon_notification_type(%Activity{}), do: nil

	def from_mastodon_notification_type(type) do
	Map.get(@mastodon_to_ap_notification_types, type)
	end

	def all_by_actor_and_id(actor, status_ids \\ [])
	def all_by_actor_and_id(_actor, []), do: []

	def all_by_actor_and_id(actor, status_ids) do
	Activity
	\|> where([s], s.id in ^status_ids)
	\|> where([s], s.actor == ^actor)
	\|> Repo.all()
	end

	def follow_requests_for_actor(%Pleroma.User{ap_id: ap_id}) do
	from(
	a in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Follow'",
	a.data
	),
	where:
	fragment(
	"? ->> 'state' = 'pending'",
	a.data
	),
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	a.data,
	a.data,
	^ap_id
	)
	)
	end

	@spec query_by_actor(actor()) :: Ecto.Query.t()
	def query_by_actor(actor) do
	from(a in Activity, where: a.actor == ^actor)
	end

	def restrict_deactivated_users(query) do
	from(activity in query,
	where:
	fragment(
	"? not in (SELECT ap_id FROM users WHERE info->'deactivated' @> 'true')",
	activity.actor
	)
	)
	end

	defdelegate search(user, query, options \\ []), to: Pleroma.Activity.Search
	end
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index 00b06f723..25e56b9e2 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,245 +1,178 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Application do
	+ import Cachex.Spec
	use Application

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]
	+ @env Mix.env()
	+
	def name, do: @name
	def version, do: @version
	def named_version, do: @name <> " " <> @version
	def repository, do: @repository

	def user_agent do
	info = "#{Pleroma.Web.base_url()} <#{Pleroma.Config.get([:instance, :email], "")}>"
	named_version() <> "; " <> info
	end

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	- import Cachex.Spec
	-
	Pleroma.Config.DeprecationWarnings.warn()
	setup_instrumenters()

	# Define workers and child supervisors to be supervised
	children =
	[
	- # Start the Ecto repository
	- %{id: Pleroma.Repo, start: {Pleroma.Repo, :start_link, []}, type: :supervisor},
	- %{id: Pleroma.Config.TransferTask, start: {Pleroma.Config.TransferTask, :start_link, []}},
	- %{id: Pleroma.Emoji, start: {Pleroma.Emoji, :start_link, []}},
	- %{id: Pleroma.Captcha, start: {Pleroma.Captcha, :start_link, []}},
	- %{
	- id: :cachex_used_captcha_cache,
	- start:
	- {Cachex, :start_link,
	- [
	- :used_captcha_cache,
	- [
	- ttl_interval:
	- :timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))
	- ]
	- ]}
	- },
	- %{
	- id: :cachex_user,
	- start:
	- {Cachex, :start_link,
	- [
	- :user_cache,
	- [
	- default_ttl: 25_000,
	- ttl_interval: 1000,
	- limit: 2500
	- ]
	- ]}
	- },
	- %{
	- id: :cachex_object,
	- start:
	- {Cachex, :start_link,
	- [
	- :object_cache,
	- [
	- default_ttl: 25_000,
	- ttl_interval: 1000,
	- limit: 2500
	- ]
	- ]}
	- },
	- %{
	- id: :cachex_rich_media,
	- start:
	- {Cachex, :start_link,
	- [
	- :rich_media_cache,
	- [
	- default_ttl: :timer.minutes(120),
	- limit: 5000
	- ]
	- ]}
	- },
	- %{
	- id: :cachex_scrubber,
	- start:
	- {Cachex, :start_link,
	- [
	- :scrubber_cache,
	- [
	- limit: 2500
	- ]
	- ]}
	- },
	- %{
	- id: :cachex_idem,
	- start:
	- {Cachex, :start_link,
	- [
	- :idempotency_cache,
	- [
	- expiration:
	- expiration(
	- default: :timer.seconds(6 * 60 * 60),
	- interval: :timer.seconds(60)
	- ),
	- limit: 2500
	- ]
	- ]}
	- },
	- %{id: Pleroma.FlakeId, start: {Pleroma.FlakeId, :start_link, []}},
	- %{
	- id: Pleroma.ScheduledActivityWorker,
	- start: {Pleroma.ScheduledActivityWorker, :start_link, []}
	- }
	+ Pleroma.Repo,
	+ Pleroma.Config.TransferTask,
	+ Pleroma.Emoji,
	+ Pleroma.Captcha,
	+ Pleroma.FlakeId,
	+ Pleroma.ScheduledActivityWorker
	] ++
	+ cachex_children() ++
	hackney_pool_children() ++
	[
	- %{
	- id: Pleroma.Web.Federator.RetryQueue,
	- start: {Pleroma.Web.Federator.RetryQueue, :start_link, []}
	- },
	- %{
	- id: Pleroma.Web.OAuth.Token.CleanWorker,
	- start: {Pleroma.Web.OAuth.Token.CleanWorker, :start_link, []}
	- },
	- %{
	- id: Pleroma.Stats,
	- start: {Pleroma.Stats, :start_link, []}
	- },
	+ Pleroma.Web.Federator.RetryQueue,
	+ Pleroma.Stats,
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	},
	%{
	id: :federator_init,
	start: {Task, :start_link, [&Pleroma.Web.Federator.init/0]},
	restart: :temporary
	},
	%{
	id: :internal_fetch_init,
	start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
	restart: :temporary
	}
	] ++
	- streamer_child() ++
	- chat_child() ++
	+ oauth_cleanup_child(oauth_cleanup_enabled?()) ++
	+ streamer_child(@env) ++
	+ chat_child(@env, chat_enabled?()) ++
	[
	- # Start the endpoint when the application starts
	- %{
	- id: Pleroma.Web.Endpoint,
	- start: {Pleroma.Web.Endpoint, :start_link, []},
	- type: :supervisor
	- },
	- %{id: Pleroma.Gopher.Server, start: {Pleroma.Gopher.Server, :start_link, []}}
	+ Pleroma.Web.Endpoint,
	+ Pleroma.Gopher.Server
	]

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
	result = Supervisor.start_link(children, opts)
	:ok = after_supervisor_start()
	result
	end

	defp setup_instrumenters do
	require Prometheus.Registry

	if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
	:ok =
	:telemetry.attach(
	"prometheus-ecto",
	[:pleroma, :repo, :query],
	&Pleroma.Repo.Instrumenter.handle_event/4,
	%{}
	)

	Pleroma.Repo.Instrumenter.setup()
	end

	Pleroma.Web.Endpoint.MetricsExporter.setup()
	Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
	Pleroma.Web.Endpoint.Instrumenter.setup()
	end

	def enabled_hackney_pools do
	[:media] ++
	if Application.get_env(:tesla, :adapter) == Tesla.Adapter.Hackney do
	[:federation]
	else
	[]
	end ++
	if Pleroma.Config.get([Pleroma.Upload, :proxy_remote]) do
	[:upload]
	else
	[]
	end
	end

	- if Pleroma.Config.get(:env) == :test do
	- defp streamer_child, do: []
	- defp chat_child, do: []
	- else
	- defp streamer_child do
	- [%{id: Pleroma.Web.Streamer, start: {Pleroma.Web.Streamer, :start_link, []}}]
	- end
	+ defp cachex_children do
	+ [
	+ build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
	+ build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	+ build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	+ build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
	+ build_cachex("scrubber", limit: 2500),
	+ build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500)
	+ ]
	+ end

	- defp chat_child do
	- if Pleroma.Config.get([:chat, :enabled]) do
	- [
	- %{
	- id: Pleroma.Web.ChatChannel.ChatChannelState,
	- start: {Pleroma.Web.ChatChannel.ChatChannelState, :start_link, []}
	- }
	- ]
	- else
	- []
	- end
	- end
	+ defp idempotency_expiration,
	+ do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))
	+
	+ defp seconds_valid_interval,
	+ do: :timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))
	+
	+ defp build_cachex(type, opts),
	+ do: %{
	+ id: String.to_atom("cachex_" <> type),
	+ start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
	+ type: :worker
	+ }
	+
	+ defp chat_enabled?, do: Pleroma.Config.get([:chat, :enabled])
	+
	+ defp oauth_cleanup_enabled?,
	+ do: Pleroma.Config.get([:oauth2, :clean_expired_tokens], false)
	+
	+ defp streamer_child(:test), do: []
	+
	+ defp streamer_child(_) do
	+ [Pleroma.Web.Streamer]
	+ end
	+
	+ defp oauth_cleanup_child(true),
	+ do: [Pleroma.Web.OAuth.Token.CleanWorker]
	+
	+ defp oauth_cleanup_child(_), do: []
	+
	+ defp chat_child(:test, _), do: []
	+
	+ defp chat_child(_env, true) do
	+ [Pleroma.Web.ChatChannel.ChatChannelState]
	end

	+ defp chat_child(_, _), do: []
	+
	defp hackney_pool_children do
	for pool <- enabled_hackney_pools() do
	options = Pleroma.Config.get([:hackney_pools, pool])
	:hackney_pool.child_spec(pool, options)
	end
	end

	defp after_supervisor_start do
	with digest_config <- Application.get_env(:pleroma, :email_notifications)[:digest],
	true <- digest_config[:active] do
	PleromaJobQueue.schedule(
	digest_config[:schedule],
	:digest_emails,
	Pleroma.DigestEmailWorker
	)
	end

	:ok
	end
	end
	diff --git a/lib/pleroma/captcha/captcha.ex b/lib/pleroma/captcha/captcha.ex
	index a73b87251..c2765a5b8 100644
	--- a/lib/pleroma/captcha/captcha.ex
	+++ b/lib/pleroma/captcha/captcha.ex
	@@ -1,114 +1,114 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Captcha do
	import Pleroma.Web.Gettext

	alias Calendar.DateTime
	alias Plug.Crypto.KeyGenerator
	alias Plug.Crypto.MessageEncryptor

	use GenServer

	@doc false
	- def start_link do
	+ def start_link(_) do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	@doc false
	def init(_) do
	{:ok, nil}
	end

	@doc """
	Ask the configured captcha service for a new captcha
	"""
	def new do
	GenServer.call(__MODULE__, :new)
	end

	@doc """
	Ask the configured captcha service to validate the captcha
	"""
	def validate(token, captcha, answer_data) do
	GenServer.call(__MODULE__, {:validate, token, captcha, answer_data})
	end

	@doc false
	def handle_call(:new, _from, state) do
	enabled = Pleroma.Config.get([__MODULE__, :enabled])

	if !enabled do
	{:reply, %{type: :none}, state}
	else
	new_captcha = method().new()

	secret_key_base = Pleroma.Config.get!([Pleroma.Web.Endpoint, :secret_key_base])

	# This make salt a little different for two keys
	token = new_captcha[:token]
	secret = KeyGenerator.generate(secret_key_base, token <> "_encrypt")
	sign_secret = KeyGenerator.generate(secret_key_base, token <> "_sign")
	# Basicallty copy what Phoenix.Token does here, add the time to
	# the actual data and make it a binary to then encrypt it
	encrypted_captcha_answer =
	%{
	at: DateTime.now_utc(),
	answer_data: new_captcha[:answer_data]
	}
	\|> :erlang.term_to_binary()
	\|> MessageEncryptor.encrypt(secret, sign_secret)

	{
	:reply,
	# Repalce the answer with the encrypted answer
	%{new_captcha \| answer_data: encrypted_captcha_answer},
	state
	}
	end
	end

	@doc false
	def handle_call({:validate, token, captcha, answer_data}, _from, state) do
	secret_key_base = Pleroma.Config.get!([Pleroma.Web.Endpoint, :secret_key_base])
	secret = KeyGenerator.generate(secret_key_base, token <> "_encrypt")
	sign_secret = KeyGenerator.generate(secret_key_base, token <> "_sign")

	# If the time found is less than (current_time-seconds_valid) then the time has already passed
	# Later we check that the time found is more than the presumed invalidatation time, that means
	# that the data is still valid and the captcha can be checked
	seconds_valid = Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid])
	valid_if_after = DateTime.subtract!(DateTime.now_utc(), seconds_valid)

	result =
	with {:ok, data} <- MessageEncryptor.decrypt(answer_data, secret, sign_secret),
	%{at: at, answer_data: answer_md5} <- :erlang.binary_to_term(data) do
	try do
	if DateTime.before?(at, valid_if_after),
	do: throw({:error, dgettext("errors", "CAPTCHA expired")})

	if not is_nil(Cachex.get!(:used_captcha_cache, token)),
	do: throw({:error, dgettext("errors", "CAPTCHA already used")})

	res = method().validate(token, captcha, answer_md5)
	# Throw if an error occurs
	if res != :ok, do: throw(res)

	# Mark this captcha as used
	{:ok, _} =
	Cachex.put(:used_captcha_cache, token, true, ttl: :timer.seconds(seconds_valid))

	:ok
	catch
	:throw, e -> e
	end
	else
	_ -> {:error, dgettext("errors", "Invalid answer data")}
	end

	{:reply, result, state}
	end

	defp method, do: Pleroma.Config.get!([__MODULE__, :method])
	end
	diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
	index 7799b2a78..3214c9951 100644
	--- a/lib/pleroma/config/transfer_task.ex
	+++ b/lib/pleroma/config/transfer_task.ex
	@@ -1,59 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTask do
	use Task
	alias Pleroma.Web.AdminAPI.Config

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

	def load_and_update_env do
	if Pleroma.Config.get([:instance, :dynamic_configuration]) and
	Ecto.Adapters.SQL.table_exists?(Pleroma.Repo, "config") do
	for_restart =
	Pleroma.Repo.all(Config)
	\|> Enum.map(&update_env(&1))

	# We need to restart applications for loaded settings take effect
	for_restart
	\|> Enum.reject(&(&1 in [:pleroma, :ok]))
	\|> Enum.each(fn app ->
	Application.stop(app)
	:ok = Application.start(app)
	end)
	end
	end

	defp update_env(setting) do
	try do
	key =
	if String.starts_with?(setting.key, "Pleroma.") do
	"Elixir." <> setting.key
	else
	String.trim_leading(setting.key, ":")
	end

	group = String.to_existing_atom(setting.group)

	Application.put_env(
	group,
	String.to_existing_atom(key),
	Config.from_binary(setting.value)
	)

	group
	rescue
	e ->
	require Logger

	Logger.warn(
	"updating env causes error, key: #{inspect(setting.key)}, error: #{inspect(e)}"
	)
	end
	end
	end
	diff --git a/lib/pleroma/emoji.ex b/lib/pleroma/emoji.ex
	index 052501642..66e20f0e4 100644
	--- a/lib/pleroma/emoji.ex
	+++ b/lib/pleroma/emoji.ex
	@@ -1,263 +1,263 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji do
	@moduledoc """
	The emojis are loaded from:

	* emoji packs in INSTANCE-DIR/emoji
	* the files: `config/emoji.txt` and `config/custom_emoji.txt`
	* glob paths, nested folder is used as tag name for grouping e.g. priv/static/emoji/custom/nested_folder

	This GenServer stores in an ETS table the list of the loaded emojis, and also allows to reload the list at runtime.
	"""
	use GenServer

	require Logger

	@type pattern :: Regex.t() \| module() \| String.t()
	@type patterns :: pattern() \| [pattern()]
	@type group_patterns :: keyword(patterns())

	@ets __MODULE__.Ets
	@ets_options [:ordered_set, :protected, :named_table, {:read_concurrency, true}]

	@doc false
	- def start_link do
	+ def start_link(_) do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	@doc "Reloads the emojis from disk."
	@spec reload() :: :ok
	def reload do
	GenServer.call(__MODULE__, :reload)
	end

	@doc "Returns the path of the emoji `name`."
	@spec get(String.t()) :: String.t() \| nil
	def get(name) do
	case :ets.lookup(@ets, name) do
	[{_, path}] -> path
	_ -> nil
	end
	end

	@doc "Returns all the emojos!!"
	@spec get_all() :: [{String.t(), String.t()}, ...]
	def get_all do
	:ets.tab2list(@ets)
	end

	@doc false
	def init(_) do
	@ets = :ets.new(@ets, @ets_options)
	GenServer.cast(self(), :reload)
	{:ok, nil}
	end

	@doc false
	def handle_cast(:reload, state) do
	load()
	{:noreply, state}
	end

	@doc false
	def handle_call(:reload, _from, state) do
	load()
	{:reply, :ok, state}
	end

	@doc false
	def terminate(_, _) do
	:ok
	end

	@doc false
	def code_change(_old_vsn, state, _extra) do
	load()
	{:ok, state}
	end

	defp load do
	emoji_dir_path =
	Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)

	emoji_groups = Pleroma.Config.get([:emoji, :groups])

	case File.ls(emoji_dir_path) do
	{:error, :enoent} ->
	# The custom emoji directory doesn't exist,
	# don't do anything
	nil

	{:error, e} ->
	# There was some other error
	Logger.error("Could not access the custom emoji directory #{emoji_dir_path}: #{e}")

	{:ok, results} ->
	grouped =
	Enum.group_by(results, fn file -> File.dir?(Path.join(emoji_dir_path, file)) end)

	packs = grouped[true] \|\| []
	files = grouped[false] \|\| []

	# Print the packs we've found
	Logger.info("Found emoji packs: #{Enum.join(packs, ", ")}")

	if not Enum.empty?(files) do
	Logger.warn(
	"Found files in the emoji folder. These will be ignored, please move them to a subdirectory\nFound files: #{
	Enum.join(files, ", ")
	}"
	)
	end

	emojis =
	Enum.flat_map(
	packs,
	fn pack -> load_pack(Path.join(emoji_dir_path, pack), emoji_groups) end
	)

	true = :ets.insert(@ets, emojis)
	end

	# Compat thing for old custom emoji handling & default emoji,
	# it should run even if there are no emoji packs
	shortcode_globs = Pleroma.Config.get([:emoji, :shortcode_globs], [])

	emojis =
	(load_from_file("config/emoji.txt", emoji_groups) ++
	load_from_file("config/custom_emoji.txt", emoji_groups) ++
	load_from_globs(shortcode_globs, emoji_groups))
	\|> Enum.reject(fn value -> value == nil end)

	true = :ets.insert(@ets, emojis)

	:ok
	end

	defp load_pack(pack_dir, emoji_groups) do
	pack_name = Path.basename(pack_dir)

	emoji_txt = Path.join(pack_dir, "emoji.txt")

	if File.exists?(emoji_txt) do
	load_from_file(emoji_txt, emoji_groups)
	else
	extensions = Pleroma.Config.get([:emoji, :pack_extensions])

	Logger.info(
	"No emoji.txt found for pack \"#{pack_name}\", assuming all #{Enum.join(extensions, ", ")} files are emoji"
	)

	make_shortcode_to_file_map(pack_dir, extensions)
	\|> Enum.map(fn {shortcode, rel_file} ->
	filename = Path.join("/emoji/#{pack_name}", rel_file)

	{shortcode, filename, [to_string(match_extra(emoji_groups, filename))]}
	end)
	end
	end

	def make_shortcode_to_file_map(pack_dir, exts) do
	find_all_emoji(pack_dir, exts)
	\|> Enum.map(&Path.relative_to(&1, pack_dir))
	\|> Enum.map(fn f -> {f \|> Path.basename() \|> Path.rootname(), f} end)
	\|> Enum.into(%{})
	end

	def find_all_emoji(dir, exts) do
	Enum.reduce(
	File.ls!(dir),
	[],
	fn f, acc ->
	filepath = Path.join(dir, f)

	if File.dir?(filepath) do
	acc ++ find_all_emoji(filepath, exts)
	else
	acc ++ [filepath]
	end
	end
	)
	\|> Enum.filter(fn f -> Path.extname(f) in exts end)
	end

	defp load_from_file(file, emoji_groups) do
	if File.exists?(file) do
	load_from_file_stream(File.stream!(file), emoji_groups)
	else
	[]
	end
	end

	defp load_from_file_stream(stream, emoji_groups) do
	stream
	\|> Stream.map(&String.trim/1)
	\|> Stream.map(fn line ->
	case String.split(line, ~r/,\s*/) do
	[name, file] ->
	{name, file, [to_string(match_extra(emoji_groups, file))]}

	[name, file \| tags] ->
	{name, file, tags}

	_ ->
	nil
	end
	end)
	\|> Enum.to_list()
	end

	defp load_from_globs(globs, emoji_groups) do
	static_path = Path.join(:code.priv_dir(:pleroma), "static")

	paths =
	Enum.map(globs, fn glob ->
	Path.join(static_path, glob)
	\|> Path.wildcard()
	end)
	\|> Enum.concat()

	Enum.map(paths, fn path ->
	tag = match_extra(emoji_groups, Path.join("/", Path.relative_to(path, static_path)))
	shortcode = Path.basename(path, Path.extname(path))
	external_path = Path.join("/", Path.relative_to(path, static_path))
	{shortcode, external_path, [to_string(tag)]}
	end)
	end

	@doc """
	Finds a matching group for the given emoji filename
	"""
	@spec match_extra(group_patterns(), String.t()) :: atom() \| nil
	def match_extra(group_patterns, filename) do
	match_group_patterns(group_patterns, fn pattern ->
	case pattern do
	%Regex{} = regex -> Regex.match?(regex, filename)
	string when is_binary(string) -> filename == string
	end
	end)
	end

	defp match_group_patterns(group_patterns, matcher) do
	Enum.find_value(group_patterns, fn {group, patterns} ->
	patterns =
	patterns
	\|> List.wrap()
	\|> Enum.map(fn pattern ->
	if String.contains?(pattern, "*") do
	~r(#{String.replace(pattern, "", ".")})
	else
	pattern
	end
	end)

	Enum.any?(patterns, matcher) && group
	end)
	end
	end
	diff --git a/lib/pleroma/flake_id.ex b/lib/pleroma/flake_id.ex
	index ca0610abc..47d61ca5f 100644
	--- a/lib/pleroma/flake_id.ex
	+++ b/lib/pleroma/flake_id.ex
	@@ -1,182 +1,182 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.FlakeId do
	@moduledoc """
	Flake is a decentralized, k-ordered id generation service.

	Adapted from:

	* [flaky](https://github.com/nirvana/flaky), released under the terms of the Truly Free License,
	* [Flake](https://github.com/boundary/flake), Copyright 2012, Boundary, Apache License, Version 2.0
	"""

	@type t :: binary

	@behaviour Ecto.Type
	use GenServer
	require Logger
	alias __MODULE__
	import Kernel, except: [to_string: 1]

	defstruct node: nil, time: 0, sq: 0

	@doc "Converts a binary Flake to a String"
	def to_string(<<0::integer-size(64), id::integer-size(64)>>) do
	Kernel.to_string(id)
	end

	def to_string(<<_::integer-size(64), _::integer-size(48), _::integer-size(16)>> = flake) do
	encode_base62(flake)
	end

	def to_string(s), do: s

	def from_string(int) when is_integer(int) do
	from_string(Kernel.to_string(int))
	end

	for i <- [-1, 0] do
	def from_string(unquote(i)), do: <<0::integer-size(128)>>
	def from_string(unquote(Kernel.to_string(i))), do: <<0::integer-size(128)>>
	end

	def from_string(<<_::integer-size(128)>> = flake), do: flake

	def from_string(string) when is_binary(string) and byte_size(string) < 18 do
	case Integer.parse(string) do
	{id, ""} -> <<0::integer-size(64), id::integer-size(64)>>
	_ -> nil
	end
	end

	def from_string(string) do
	string \|> decode_base62 \|> from_integer
	end

	def to_integer(<<integer::integer-size(128)>>), do: integer

	def from_integer(integer) do
	<<_time::integer-size(64), _node::integer-size(48), _seq::integer-size(16)>> =
	<<integer::integer-size(128)>>
	end

	@doc "Generates a Flake"
	@spec get :: binary
	def get, do: to_string(:gen_server.call(:flake, :get))

	# checks that ID is is valid FlakeID
	#
	@spec is_flake_id?(String.t()) :: boolean
	def is_flake_id?(id), do: is_flake_id?(String.to_charlist(id), true)
	defp is_flake_id?([c \| cs], true) when c >= ?0 and c <= ?9, do: is_flake_id?(cs, true)
	defp is_flake_id?([c \| cs], true) when c >= ?A and c <= ?Z, do: is_flake_id?(cs, true)
	defp is_flake_id?([c \| cs], true) when c >= ?a and c <= ?z, do: is_flake_id?(cs, true)
	defp is_flake_id?([], true), do: true
	defp is_flake_id?(_, _), do: false

	# -- Ecto.Type API
	@impl Ecto.Type
	def type, do: :uuid

	@impl Ecto.Type
	def cast(value) do
	{:ok, FlakeId.to_string(value)}
	end

	@impl Ecto.Type
	def load(value) do
	{:ok, FlakeId.to_string(value)}
	end

	@impl Ecto.Type
	def dump(value) do
	{:ok, FlakeId.from_string(value)}
	end

	def autogenerate, do: get()

	# -- GenServer API
	- def start_link do
	+ def start_link(_) do
	:gen_server.start_link({:local, :flake}, __MODULE__, [], [])
	end

	@impl GenServer
	def init([]) do
	{:ok, %FlakeId{node: worker_id(), time: time()}}
	end

	@impl GenServer
	def handle_call(:get, _from, state) do
	{flake, new_state} = get(time(), state)
	{:reply, flake, new_state}
	end

	# Matches when the calling time is the same as the state time. Incr. sq
	defp get(time, %FlakeId{time: time, node: node, sq: seq}) do
	new_state = %FlakeId{time: time, node: node, sq: seq + 1}
	{gen_flake(new_state), new_state}
	end

	# Matches when the times are different, reset sq
	defp get(newtime, %FlakeId{time: time, node: node}) when newtime > time do
	new_state = %FlakeId{time: newtime, node: node, sq: 0}
	{gen_flake(new_state), new_state}
	end

	# Error when clock is running backwards
	defp get(newtime, %FlakeId{time: time}) when newtime < time do
	{:error, :clock_running_backwards}
	end

	defp gen_flake(%FlakeId{time: time, node: node, sq: seq}) do
	<<time::integer-size(64), node::integer-size(48), seq::integer-size(16)>>
	end

	defp nthchar_base62(n) when n <= 9, do: ?0 + n
	defp nthchar_base62(n) when n <= 35, do: ?A + n - 10
	defp nthchar_base62(n), do: ?a + n - 36

	defp encode_base62(<<integer::integer-size(128)>>) do
	integer
	\|> encode_base62([])
	\|> List.to_string()
	end

	defp encode_base62(int, acc) when int < 0, do: encode_base62(-int, acc)
	defp encode_base62(int, []) when int == 0, do: '0'
	defp encode_base62(int, acc) when int == 0, do: acc

	defp encode_base62(int, acc) do
	r = rem(int, 62)
	id = div(int, 62)
	acc = [nthchar_base62(r) \| acc]
	encode_base62(id, acc)
	end

	defp decode_base62(s) do
	decode_base62(String.to_charlist(s), 0)
	end

	defp decode_base62([c \| cs], acc) when c >= ?0 and c <= ?9,
	do: decode_base62(cs, 62 * acc + (c - ?0))

	defp decode_base62([c \| cs], acc) when c >= ?A and c <= ?Z,
	do: decode_base62(cs, 62 * acc + (c - ?A + 10))

	defp decode_base62([c \| cs], acc) when c >= ?a and c <= ?z,
	do: decode_base62(cs, 62 * acc + (c - ?a + 36))

	defp decode_base62([], acc), do: acc

	defp time do
	{mega_seconds, seconds, micro_seconds} = :erlang.timestamp()
	1_000_000_000 * mega_seconds + seconds * 1000 + :erlang.trunc(micro_seconds / 1000)
	end

	defp worker_id do
	<<worker::integer-size(48)>> = :crypto.strong_rand_bytes(6)
	worker
	end
	end
	diff --git a/lib/pleroma/gopher/server.ex b/lib/pleroma/gopher/server.ex
	index b3319e137..d4e4f3e55 100644
	--- a/lib/pleroma/gopher/server.ex
	+++ b/lib/pleroma/gopher/server.ex
	@@ -1,159 +1,159 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Gopher.Server do
	use GenServer
	require Logger

	- def start_link do
	+ def start_link(_) do
	config = Pleroma.Config.get(:gopher, [])
	ip = Keyword.get(config, :ip, {0, 0, 0, 0})
	port = Keyword.get(config, :port, 1234)

	if Keyword.get(config, :enabled, false) do
	GenServer.start_link(__MODULE__, [ip, port], [])
	else
	Logger.info("Gopher server disabled")
	:ignore
	end
	end

	def init([ip, port]) do
	Logger.info("Starting gopher server on #{port}")

	:ranch.start_listener(
	:gopher,
	100,
	:ranch_tcp,
	[ip: ip, port: port],
	__MODULE__.ProtocolHandler,
	[]
	)

	{:ok, %{ip: ip, port: port}}
	end
	end

	defmodule Pleroma.Gopher.Server.ProtocolHandler do
	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility

	def start_link(ref, socket, transport, opts) do
	pid = spawn_link(__MODULE__, :init, [ref, socket, transport, opts])
	{:ok, pid}
	end

	def init(ref, socket, transport, [] = _Opts) do
	:ok = :ranch.accept_ack(ref)
	loop(socket, transport)
	end

	def info(text) do
	text = String.replace(text, ~r/[\t\n]/, "")

	String.split(text, "\r")
	\|> Enum.map(fn text ->
	"i#{text}\tfake\t(NULL)\t0\r\n"
	end)
	\|> Enum.join("")
	end

	def link(name, selector, type \\ 1) do
	address = Pleroma.Web.Endpoint.host()
	port = Pleroma.Config.get([:gopher, :port], 1234)
	dstport = Pleroma.Config.get([:gopher, :dstport], port)
	"#{type}#{name}\t#{selector}\t#{address}\t#{dstport}\r\n"
	end

	def render_activities(activities) do
	activities
	\|> Enum.reverse()
	\|> Enum.map(fn activity ->
	user = User.get_cached_by_ap_id(activity.data["actor"])

	object = Object.normalize(activity)
	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0

	link("Post ##{activity.id} by #{user.nickname}", "/notices/#{activity.id}") <>
	info("#{like_count} likes, #{announcement_count} repeats") <>
	"i\tfake\t(NULL)\t0\r\n" <>
	info(HTML.strip_tags(String.replace(object.data["content"], "<br>", "\r")))
	end)
	\|> Enum.join("i\tfake\t(NULL)\t0\r\n")
	end

	def response("") do
	info("Welcome to #{Pleroma.Config.get([:instance, :name], "Pleroma")}!") <>
	link("Public Timeline", "/main/public") <>
	link("Federated Timeline", "/main/all") <> ".\r\n"
	end

	def response("/main/public") do
	posts =
	ActivityPub.fetch_public_activities(%{"type" => ["Create"], "local_only" => true})
	\|> render_activities

	info("Welcome to the Public Timeline!") <> posts <> ".\r\n"
	end

	def response("/main/all") do
	posts =
	ActivityPub.fetch_public_activities(%{"type" => ["Create"]})
	\|> render_activities

	info("Welcome to the Federated Timeline!") <> posts <> ".\r\n"
	end

	def response("/notices/" <> id) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	true <- Visibility.is_public?(activity) do
	activities =
	ActivityPub.fetch_activities_for_context(activity.data["context"])
	\|> render_activities

	user = User.get_cached_by_ap_id(activity.data["actor"])

	info("Post #{activity.id} by #{user.nickname}") <>
	link("More posts by #{user.nickname}", "/users/#{user.nickname}") <> activities <> ".\r\n"
	else
	_e ->
	info("Not public") <> ".\r\n"
	end
	end

	def response("/users/" <> nickname) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	params = %{
	"type" => ["Create"],
	"actor_id" => user.ap_id
	}

	activities =
	ActivityPub.fetch_public_activities(params)
	\|> render_activities

	info("Posts by #{user.nickname}") <> activities <> ".\r\n"
	else
	_e ->
	info("No such user") <> ".\r\n"
	end
	end

	def loop(socket, transport) do
	case transport.recv(socket, 0, 5000) do
	{:ok, data} ->
	data = String.trim_trailing(data, "\r\n")
	transport.send(socket, response(data))
	:ok = transport.close(socket)

	_ ->
	:ok = transport.close(socket)
	end
	end
	end
	diff --git a/lib/pleroma/html.ex b/lib/pleroma/html.ex
	index 2fae7281c..06e60cba3 100644
	--- a/lib/pleroma/html.ex
	+++ b/lib/pleroma/html.ex
	@@ -1,282 +1,284 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTML do
	alias HtmlSanitizeEx.Scrubber

	defp get_scrubbers(scrubber) when is_atom(scrubber), do: [scrubber]
	defp get_scrubbers(scrubbers) when is_list(scrubbers), do: scrubbers
	defp get_scrubbers(_), do: [Pleroma.HTML.Scrubber.Default]

	def get_scrubbers do
	Pleroma.Config.get([:markup, :scrub_policy])
	\|> get_scrubbers
	end

	def filter_tags(html, nil) do
	filter_tags(html, get_scrubbers())
	end

	def filter_tags(html, scrubbers) when is_list(scrubbers) do
	Enum.reduce(scrubbers, html, fn scrubber, html ->
	filter_tags(html, scrubber)
	end)
	end

	def filter_tags(html, scrubber), do: Scrubber.scrub(html, scrubber)
	def filter_tags(html), do: filter_tags(html, nil)
	def strip_tags(html), do: Scrubber.scrub(html, Scrubber.StripTags)

	def get_cached_scrubbed_html_for_activity(
	content,
	scrubbers,
	activity,
	key \\ "",
	callback \\ fn x -> x end
	) do
	key = "#{key}#{generate_scrubber_signature(scrubbers)}\|#{activity.id}"

	Cachex.fetch!(:scrubber_cache, key, fn _key ->
	object = Pleroma.Object.normalize(activity)
	ensure_scrubbed_html(content, scrubbers, object.data["fake"] \|\| false, callback)
	end)
	end

	def get_cached_stripped_html_for_activity(content, activity, key) do
	get_cached_scrubbed_html_for_activity(
	content,
	HtmlSanitizeEx.Scrubber.StripTags,
	activity,
	key,
	&HtmlEntities.decode/1
	)
	end

	def ensure_scrubbed_html(
	content,
	scrubbers,
	fake,
	callback
	) do
	content =
	content
	\|> filter_tags(scrubbers)
	\|> callback.()

	if fake do
	{:ignore, content}
	else
	{:commit, content}
	end
	end

	defp generate_scrubber_signature(scrubber) when is_atom(scrubber) do
	generate_scrubber_signature([scrubber])
	end

	defp generate_scrubber_signature(scrubbers) do
	Enum.reduce(scrubbers, "", fn scrubber, signature ->
	"#{signature}#{to_string(scrubber)}"
	end)
	end

	def extract_first_external_url(_, nil), do: {:error, "No content"}

	def extract_first_external_url(object, content) do
	key = "URL\|#{object.id}"

	Cachex.fetch!(:scrubber_cache, key, fn _key ->
	result =
	content
	\|> Floki.filter_out("a.mention,a.hashtag,a[rel~=\"tag\"]")
	\|> Floki.attribute("a", "href")
	\|> Enum.at(0)

	{:commit, {:ok, result}}
	end)
	end
	end

	defmodule Pleroma.HTML.Scrubber.TwitterText do
	@moduledoc """
	An HTML scrubbing policy which limits to twitter-style text. Only
	paragraphs, breaks and links are allowed through the filter.
	"""

	@valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])

	require HtmlSanitizeEx.Scrubber.Meta
	alias HtmlSanitizeEx.Scrubber.Meta

	Meta.remove_cdata_sections_before_scrub()
	Meta.strip_comments()

	# links
	Meta.allow_tag_with_uri_attributes("a", ["href", "data-user", "data-tag"], @valid_schemes)

	Meta.allow_tag_with_this_attribute_values("a", "class", [
	"hashtag",
	"u-url",
	"mention",
	"u-url mention",
	"mention u-url"
	])

	Meta.allow_tag_with_this_attribute_values("a", "rel", [
	"tag",
	"nofollow",
	"noopener",
	"noreferrer"
	])

	Meta.allow_tag_with_these_attributes("a", ["name", "title"])

	# paragraphs and linebreaks
	Meta.allow_tag_with_these_attributes("br", [])
	Meta.allow_tag_with_these_attributes("p", [])

	# microformats
	Meta.allow_tag_with_this_attribute_values("span", "class", ["h-card"])
	Meta.allow_tag_with_these_attributes("span", [])

	# allow inline images for custom emoji
	if Pleroma.Config.get([:markup, :allow_inline_images]) do
	# restrict img tags to http/https only, because of MediaProxy.
	Meta.allow_tag_with_uri_attributes("img", ["src"], ["http", "https"])

	Meta.allow_tag_with_these_attributes("img", [
	"width",
	"height",
	"class",
	"title",
	"alt"
	])
	end

	Meta.strip_everything_not_covered()
	end

	defmodule Pleroma.HTML.Scrubber.Default do
	@doc "The default HTML scrubbing policy: no "

	require HtmlSanitizeEx.Scrubber.Meta
	alias HtmlSanitizeEx.Scrubber.Meta
	# credo:disable-for-previous-line
	# No idea how to fix this one…

	@valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])

	Meta.remove_cdata_sections_before_scrub()
	Meta.strip_comments()

	Meta.allow_tag_with_uri_attributes("a", ["href", "data-user", "data-tag"], @valid_schemes)

	Meta.allow_tag_with_this_attribute_values("a", "class", [
	"hashtag",
	"u-url",
	"mention",
	"u-url mention",
	"mention u-url"
	])

	Meta.allow_tag_with_this_attribute_values("a", "rel", [
	"tag",
	"nofollow",
	"noopener",
	"noreferrer"
	])

	Meta.allow_tag_with_these_attributes("a", ["name", "title"])

	Meta.allow_tag_with_these_attributes("abbr", ["title"])

	Meta.allow_tag_with_these_attributes("b", [])
	Meta.allow_tag_with_these_attributes("blockquote", [])
	Meta.allow_tag_with_these_attributes("br", [])
	Meta.allow_tag_with_these_attributes("code", [])
	Meta.allow_tag_with_these_attributes("del", [])
	Meta.allow_tag_with_these_attributes("em", [])
	Meta.allow_tag_with_these_attributes("i", [])
	Meta.allow_tag_with_these_attributes("li", [])
	Meta.allow_tag_with_these_attributes("ol", [])
	Meta.allow_tag_with_these_attributes("p", [])
	Meta.allow_tag_with_these_attributes("pre", [])
	Meta.allow_tag_with_these_attributes("strong", [])
	+ Meta.allow_tag_with_these_attributes("sub", [])
	+ Meta.allow_tag_with_these_attributes("sup", [])
	Meta.allow_tag_with_these_attributes("u", [])
	Meta.allow_tag_with_these_attributes("ul", [])

	Meta.allow_tag_with_this_attribute_values("span", "class", ["h-card"])
	Meta.allow_tag_with_these_attributes("span", [])

	@allow_inline_images Pleroma.Config.get([:markup, :allow_inline_images])

	if @allow_inline_images do
	# restrict img tags to http/https only, because of MediaProxy.
	Meta.allow_tag_with_uri_attributes("img", ["src"], ["http", "https"])

	Meta.allow_tag_with_these_attributes("img", [
	"width",
	"height",
	"class",
	"title",
	"alt"
	])
	end

	if Pleroma.Config.get([:markup, :allow_tables]) do
	Meta.allow_tag_with_these_attributes("table", [])
	Meta.allow_tag_with_these_attributes("tbody", [])
	Meta.allow_tag_with_these_attributes("td", [])
	Meta.allow_tag_with_these_attributes("th", [])
	Meta.allow_tag_with_these_attributes("thead", [])
	Meta.allow_tag_with_these_attributes("tr", [])
	end

	if Pleroma.Config.get([:markup, :allow_headings]) do
	Meta.allow_tag_with_these_attributes("h1", [])
	Meta.allow_tag_with_these_attributes("h2", [])
	Meta.allow_tag_with_these_attributes("h3", [])
	Meta.allow_tag_with_these_attributes("h4", [])
	Meta.allow_tag_with_these_attributes("h5", [])
	end

	if Pleroma.Config.get([:markup, :allow_fonts]) do
	Meta.allow_tag_with_these_attributes("font", ["face"])
	end

	Meta.strip_everything_not_covered()
	end

	defmodule Pleroma.HTML.Transform.MediaProxy do
	@moduledoc "Transforms inline image URIs to use MediaProxy."

	alias Pleroma.Web.MediaProxy

	def before_scrub(html), do: html

	def scrub_attribute("img", {"src", "http" <> target}) do
	media_url =
	("http" <> target)
	\|> MediaProxy.url()

	{"src", media_url}
	end

	def scrub_attribute(_tag, attribute), do: attribute

	def scrub({"img", attributes, children}) do
	attributes =
	attributes
	\|> Enum.map(fn attr -> scrub_attribute("img", attr) end)
	\|> Enum.reject(&is_nil(&1))

	{"img", attributes, children}
	end

	def scrub({:comment, _children}), do: ""

	def scrub({tag, attributes, children}), do: {tag, attributes, children}
	def scrub({_tag, children}), do: children
	def scrub(text), do: text
	end
	diff --git a/lib/pleroma/scheduled_activity_worker.ex b/lib/pleroma/scheduled_activity_worker.ex
	index 65b38622f..8578cab5e 100644
	--- a/lib/pleroma/scheduled_activity_worker.ex
	+++ b/lib/pleroma/scheduled_activity_worker.ex
	@@ -1,58 +1,58 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ScheduledActivityWorker do
	@moduledoc """
	Sends scheduled activities to the job queue.
	"""

	alias Pleroma.Config
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	use GenServer
	require Logger

	@schedule_interval :timer.minutes(1)

	- def start_link do
	+ def start_link(_) do
	GenServer.start_link(__MODULE__, nil)
	end

	def init(_) do
	if Config.get([ScheduledActivity, :enabled]) do
	schedule_next()
	{:ok, nil}
	else
	:ignore
	end
	end

	def perform(:execute, scheduled_activity_id) do
	try do
	{:ok, scheduled_activity} = ScheduledActivity.delete(scheduled_activity_id)
	%User{} = user = User.get_cached_by_id(scheduled_activity.user_id)
	{:ok, _result} = CommonAPI.post(user, scheduled_activity.params)
	rescue
	error ->
	Logger.error(
	"#{__MODULE__} Couldn't create a status from the scheduled activity: #{inspect(error)}"
	)
	end
	end

	def handle_info(:perform, state) do
	ScheduledActivity.due_activities(@schedule_interval)
	\|> Enum.each(fn scheduled_activity ->
	PleromaJobQueue.enqueue(:scheduled_activities, __MODULE__, [:execute, scheduled_activity.id])
	end)

	schedule_next()
	{:noreply, state}
	end

	defp schedule_next do
	Process.send_after(self(), :perform, @schedule_interval)
	end
	end
	diff --git a/lib/pleroma/stats.ex b/lib/pleroma/stats.ex
	index 5b242927b..df80fbaa4 100644
	--- a/lib/pleroma/stats.ex
	+++ b/lib/pleroma/stats.ex
	@@ -1,59 +1,85 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Stats do
	import Ecto.Query
	alias Pleroma.Repo
	alias Pleroma.User

	- def start_link do
	- agent = Agent.start_link(fn -> {[], %{}} end, name: __MODULE__)
	- spawn(fn -> schedule_update() end)
	- agent
	+ use GenServer
	+
	+ @interval 1000 * 60 * 60
	+
	+ def start_link(_) do
	+ GenServer.start_link(__MODULE__, initial_data(), name: __MODULE__)
	+ end
	+
	+ def force_update do
	+ GenServer.call(__MODULE__, :force_update)
	end

	def get_stats do
	- Agent.get(__MODULE__, fn {_, stats} -> stats end)
	+ %{stats: stats} = GenServer.call(__MODULE__, :get_state)
	+
	+ stats
	end

	def get_peers do
	- Agent.get(__MODULE__, fn {peers, _} -> peers end)
	+ %{peers: peers} = GenServer.call(__MODULE__, :get_state)
	+
	+ peers
	+ end
	+
	+ def init(args) do
	+ Process.send(self(), :run_update, [])
	+ {:ok, args}
	+ end
	+
	+ def handle_call(:force_update, _from, _state) do
	+ new_stats = get_stat_data()
	+ {:reply, new_stats, new_stats}
	end

	- def schedule_update do
	- spawn(fn ->
	- # 1 hour
	- Process.sleep(1000 * 60 * 60)
	- schedule_update()
	- end)
	+ def handle_call(:get_state, _from, state) do
	+ {:reply, state, state}
	+ end
	+
	+ def handle_info(:run_update, _state) do
	+ new_stats = get_stat_data()
	+
	+ Process.send_after(self(), :run_update, @interval)
	+ {:noreply, new_stats}
	+ end

	- update_stats()
	+ defp initial_data do
	+ %{peers: [], stats: %{}}
	end

	- def update_stats do
	+ defp get_stat_data do
	peers =
	from(
	u in User,
	select: fragment("distinct split_part(?, '@', 2)", u.nickname),
	where: u.local != ^true
	)
	\|> Repo.all()
	\|> Enum.filter(& &1)

	domain_count = Enum.count(peers)

	status_query =
	from(u in User.Query.build(%{local: true}),
	select: fragment("sum((?->>'note_count')::int)", u.info)
	)

	status_count = Repo.one(status_query)

	user_count = Repo.aggregate(User.Query.build(%{local: true, active: true}), :count, :id)

	- Agent.update(__MODULE__, fn _ ->
	- {peers, %{domain_count: domain_count, status_count: status_count, user_count: user_count}}
	- end)
	+ %{
	+ peers: peers,
	+ stats: %{domain_count: domain_count, status_count: status_count, user_count: user_count}
	+ }
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 7d18f099e..a1040fe71 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1564 +1,1590 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 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

	alias Comeonin.Pbkdf2
	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.Keys
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.RepoStreamer
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.RelMe
	alias Pleroma.Web.Websub

	require Logger

	@type t :: %__MODULE__{}

	@primary_key {:id, Pleroma.FlakeId, 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_-]+$/

	schema "users" do
	field(: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(:following, {:array, :string}, default: [])
	field(:ap_id, :string)
	field(:avatar, :map)
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	embeds_one(:info, User.Info)

	timestamps()
	end

	def auth_active?(%User{info: %User.Info{confirmation_pending: true}}),
	do: !Pleroma.Config.get([:instance, :account_activation_required])

	def auth_active?(%User{}), do: true

	def visible_for?(user, for_user \\ nil)

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

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

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

	def superuser?(%User{local: true, info: %User.Info{is_admin: true}}), do: true
	def superuser?(%User{local: true, info: %User.Info{is_moderator: true}}), do: true
	def superuser?(_), do: false

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

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

	def profile_url(%User{info: %{source_data: %{"url" => url}}}), do: url
	def profile_url(%User{ap_id: ap_id}), do: ap_id
	def profile_url(_), do: nil

	def ap_id(%User{nickname: nickname}) do
	"#{Web.base_url()}/users/#{nickname}"
	end

	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()) :: Sring.t()
	def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
	def ap_following(%User{} = user), do: "#{ap_id(user)}/following"

	def user_info(%User{} = user, args \\ %{}) do
	following_count =
	if args[:following_count],
	do: args[:following_count],
	else: user.info.following_count \|\| following_count(user)

	follower_count =
	if args[:follower_count], do: args[:follower_count], else: user.info.follower_count

	%{
	note_count: user.info.note_count,
	locked: user.info.locked,
	confirmation_pending: user.info.confirmation_pending,
	default_scope: user.info.default_scope
	}
	\|> Map.put(:following_count, following_count)
	\|> Map.put(:follower_count, follower_count)
	end

	+ def follow_state(%User{} = user, %User{} = target) do
	+ follow_activity = Utils.fetch_latest_follow(user, target)
	+
	+ if follow_activity,
	+ do: follow_activity.data["state"],
	+ # Ideally this would be nil, but then Cachex does not commit the value
	+ else: false
	+ end
	+
	+ def get_cached_follow_state(user, target) do
	+ key = "follow_state:#{user.ap_id}\|#{target.ap_id}"
	+ Cachex.fetch!(:user_cache, key, fn _ -> {:commit, follow_state(user, target)} end)
	+ end
	+
	+ def set_follow_state_cache(user_ap_id, target_ap_id, state) do
	+ Cachex.put(
	+ :user_cache,
	+ "follow_state:#{user_ap_id}\|#{target_ap_id}",
	+ state
	+ )
	+ end
	+
	def set_info_cache(user, args) do
	Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user, args))
	end

	@spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
	def restrict_deactivated(query) do
	from(u in query,
	where: not fragment("? \\? 'deactivated' AND ?->'deactivated' @> 'true'", u.info, u.info)
	)
	end

	def following_count(%User{following: []}), do: 0

	def following_count(%User{} = user) do
	user
	\|> get_friends_query()
	\|> Repo.aggregate(:count, :id)
	end

	def remote_user_creation(params) do
	- params =
	- params
	- \|> Map.put(:info, params[:info] \|\| %{})
	+ bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	+ name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	+ params = Map.put(params, :info, params[:info] \|\| %{})
	info_cng = User.Info.remote_user_creation(%User.Info{}, params[:info])

	changes =
	%User{}
	\|> cast(params, [:bio, :name, :ap_id, :nickname, :avatar])
	\|> validate_required([:name, :ap_id])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	- \|> validate_length(:bio, max: 5000)
	- \|> validate_length(:name, max: 100)
	+ \|> validate_length(:bio, max: bio_limit)
	+ \|> validate_length(:name, max: name_limit)
	\|> put_change(:local, false)
	\|> put_embed(:info, info_cng)

	if changes.valid? do
	case info_cng.changes[:source_data] do
	%{"followers" => followers, "following" => following} ->
	changes
	\|> put_change(:follower_address, followers)
	\|> put_change(:following_address, following)

	_ ->
	followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})

	changes
	\|> put_change(:follower_address, followers)
	end
	else
	changes
	end
	end

	def update_changeset(struct, params \\ %{}) do
	+ bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	+ name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
	+
	struct
	\|> cast(params, [:bio, :name, :avatar, :following])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	- \|> validate_length(:bio, max: 5000)
	- \|> validate_length(:name, min: 1, max: 100)
	+ \|> validate_length(:bio, max: bio_limit)
	+ \|> validate_length(:name, min: 1, max: name_limit)
	end

	def upgrade_changeset(struct, params \\ %{}) do
	- params =
	- params
	- \|> Map.put(:last_refreshed_at, NaiveDateTime.utc_now())
	+ bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	+ name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	- info_cng =
	- struct.info
	- \|> User.Info.user_upgrade(params[:info])
	+ params = Map.put(params, :last_refreshed_at, NaiveDateTime.utc_now())
	+ info_cng = User.Info.user_upgrade(struct.info, params[:info])

	struct
	\|> cast(params, [
	:bio,
	:name,
	:follower_address,
	:following_address,
	:avatar,
	:last_refreshed_at
	])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	- \|> validate_length(:bio, max: 5000)
	- \|> validate_length(:name, max: 100)
	+ \|> validate_length(:bio, max: bio_limit)
	+ \|> validate_length(:name, max: name_limit)
	\|> put_embed(:info, info_cng)
	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
	end

	@spec reset_password(User.t(), map) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def reset_password(%User{id: user_id} = user, data) do
	multi =
	Multi.new()
	\|> Multi.update(:user, password_update_changeset(user, data))
	\|> 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 register_changeset(struct, params \\ %{}, opts \\ []) do
	+ bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	+ name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
	+
	need_confirmation? =
	if is_nil(opts[:need_confirmation]) do
	Pleroma.Config.get([:instance, :account_activation_required])
	else
	opts[:need_confirmation]
	end

	info_change =
	User.Info.confirmation_changeset(%User.Info{}, need_confirmation: need_confirmation?)

	changeset =
	struct
	\|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_format(:email, @email_regex)
	- \|> validate_length(:bio, max: 1000)
	- \|> validate_length(:name, min: 1, max: 100)
	+ \|> validate_length(:bio, max: bio_limit)
	+ \|> validate_length(:name, min: 1, max: name_limit)
	\|> put_change(:info, info_change)

	changeset =
	if opts[:external] do
	changeset
	else
	validate_required(changeset, [:email])
	end

	if changeset.valid? do
	ap_id = User.ap_id(%User{nickname: changeset.changes[:nickname]})
	followers = User.ap_followers(%User{nickname: changeset.changes[:nickname]})

	changeset
	\|> put_password_hash
	\|> put_change(:ap_id, ap_id)
	\|> unique_constraint(:ap_id)
	\|> put_change(:following, [followers])
	\|> put_change(:follower_address, followers)
	else
	changeset
	end
	end

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

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

	follow_all(user, autofollowed_users)
	end

	@doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
	def register(%Ecto.Changeset{} = changeset) do
	with {:ok, user} <- Repo.insert(changeset),
	{:ok, user} <- autofollow_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
	{:ok, _} <- try_send_confirmation_email(user) do
	{:ok, user}
	end
	end

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

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

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

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

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

	def needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def maybe_direct_follow(%User{} = follower, %User{local: true, info: %{locked: true}}) do
	{:ok, follower}
	end

	def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
	follow(follower, followed)
	end

	def maybe_direct_follow(%User{} = follower, %User{} = followed) do
	if not User.ap_enabled?(followed) do
	follow(follower, followed)
	else
	{:ok, follower}
	end
	end

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

	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [
	set: [
	following:
	fragment(
	"array(select distinct unnest (array_cat(?, ?)))",
	u.following,
	^followed_addresses
	)
	]
	],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	Enum.each(followeds, fn followed ->
	update_follower_count(followed)
	end)

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{info: info} = followed) do
	deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
	ap_followers = followed.follower_address

	cond do
	info.deactivated ->
	{:error, "Could not follow user: You are deactivated."}

	deny_follow_blocked and blocks?(followed, follower) ->
	{:error, "Could not follow user: #{followed.nickname} blocked you."}

	true ->
	if !followed.local && follower.local && !ap_enabled?(followed) do
	Websub.subscribe(follower, followed)
	end

	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [push: [following: ^ap_followers]],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	follower = maybe_update_following_count(follower)

	{:ok, _} = update_follower_count(followed)

	set_cache(follower)
	end
	end

	def unfollow(%User{} = follower, %User{} = followed) do
	ap_followers = followed.follower_address

	if following?(follower, followed) and follower.ap_id != followed.ap_id do
	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [pull: [following: ^ap_followers]],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	follower = maybe_update_following_count(follower)

	{:ok, followed} = update_follower_count(followed)

	set_cache(follower)

	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}
	else
	{:error, "Not subscribed!"}
	end
	end

	@spec following?(User.t(), User.t()) :: boolean
	def following?(%User{} = follower, %User{} = followed) do
	Enum.member?(follower.following, followed.follower_address)
	end

	def locked?(%User{} = user) do
	user.info.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

	# 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, "user_info:#{user.id}", user_info(user))
	{:ok, user}
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	set_cache(user)
	else
	e -> e
	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, "user_info:#{user.id}")
	end

	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"
	Cachex.fetch!(:user_cache, key, fn _ -> get_by_ap_id(ap_id) 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 ->
	user_result = get_or_fetch_by_nickname(nickname)

	case user_result do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id) do
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)
	end

	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 get_cached_user_info(user) do
	key = "user_info:#{user.id}"
	Cachex.fetch!(:user_cache, key, fn _ -> user_info(user) end)
	end

	def fetch_by_nickname(nickname) do
	ap_try = ActivityPub.make_user_from_nickname(nickname)

	case ap_try do
	{:ok, user} -> {:ok, user}
	_ -> OStatus.make_user(nickname)
	end
	end

	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
	if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do
	fetch_initial_posts(user)
	end

	{:ok, user}
	else
	_e -> {:error, "not found " <> nickname}
	end
	end
	end

	@doc "Fetch some posts when the user has just been federated with"
	def fetch_initial_posts(user),
	do: PleromaJobQueue.enqueue(:background, __MODULE__, [:fetch_initial_posts, user])

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

	def get_followers_query(user, page) do
	from(u in get_followers_query(user, nil))
	\|> User.Query.paginate(page, 20)
	end

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

	@spec get_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
	def get_followers(user, page \\ nil) do
	q = get_followers_query(user, page)

	{:ok, Repo.all(q)}
	end

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

	{:ok, Repo.all(q)}
	end

	def get_followers_ids(user, page \\ nil) do
	q = get_followers_query(user, page)

	Repo.all(from(u in q, select: u.id))
	end

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

	def get_friends_query(user, page) do
	from(u in get_friends_query(user, nil))
	\|> User.Query.paginate(page, 20)
	end

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

	def get_friends(user, page \\ nil) do
	q = get_friends_query(user, page)

	{:ok, Repo.all(q)}
	end

	def get_friends_ids(user, page \\ nil) do
	q = get_friends_query(user, page)

	Repo.all(from(u in q, select: u.id))
	end

	@spec get_follow_requests(User.t()) :: {:ok, [User.t()]}
	def get_follow_requests(%User{} = user) do
	users =
	Activity.follow_requests_for_actor(user)
	\|> join(:inner, [a], u in User, on: a.actor == u.ap_id)
	\|> where([a, u], not fragment("? @> ?", u.following, ^[user.follower_address]))
	\|> group_by([a, u], u.id)
	\|> select([a, u], u)
	\|> Repo.all()

	{:ok, users}
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	info:
	fragment(
	"jsonb_set(?, '{note_count}', ((?->>'note_count')::int + 1)::varchar::jsonb, true)",
	u.info,
	u.info
	)
	]
	)
	\|> 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: [
	info:
	fragment(
	"jsonb_set(?, '{note_count}', (greatest(0, (?->>'note_count')::int - 1))::varchar::jsonb, true)",
	u.info,
	u.info
	)
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

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

	note_count = Repo.one(note_count_query)

	info_cng = User.Info.set_note_count(user.info, note_count)

	user
	\|> change()
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache()
	end

	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
	info_cng = User.Info.follow_information_update(user.info, info)

	changeset =
	user
	\|> change()
	\|> put_embed(:info, info_cng)

	update_and_set_cache(changeset)
	else
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

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

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

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

	def maybe_update_following_count(user), do: user

	def remove_duplicated_following(%User{following: following} = user) do
	uniq_following = Enum.uniq(following)

	if length(following) == length(uniq_following) do
	{:ok, user}
	else
	user
	\|> update_changeset(%{following: uniq_following})
	\|> update_and_set_cache()
	end
	end

	@spec get_users_from_set([String.t()], boolean()) :: [User.t()]
	def get_users_from_set(ap_ids, local_only \\ true) do
	criteria = %{ap_id: ap_ids, deactivated: false}
	criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria

	User.Query.build(criteria)
	\|> Repo.all()
	end

	@spec get_recipients_from_activity(Activity.t()) :: [User.t()]
	def get_recipients_from_activity(%Activity{recipients: to}) do
	User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
	\|> Repo.all()
	end

	@spec mute(User.t(), User.t(), boolean()) :: {:ok, User.t()} \| {:error, String.t()}
	def mute(muter, %User{ap_id: ap_id}, notifications? \\ true) do
	info = muter.info

	info_cng =
	User.Info.add_to_mutes(info, ap_id)
	\|> User.Info.add_to_muted_notifications(info, ap_id, notifications?)

	cng =
	change(muter)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def unmute(muter, %{ap_id: ap_id}) do
	info = muter.info

	info_cng =
	User.Info.remove_from_mutes(info, ap_id)
	\|> User.Info.remove_from_muted_notifications(info, ap_id)

	cng =
	change(muter)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

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

	with %User{} = subscribed <- get_cached_by_ap_id(ap_id) do
	blocked = blocks?(subscribed, subscriber) and deny_follow_blocked

	if blocked do
	{:error, "Could not subscribe: #{subscribed.nickname} is blocking you"}
	else
	info_cng =
	subscribed.info
	\|> User.Info.add_to_subscribers(subscriber.ap_id)

	change(subscribed)
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache()
	end
	end
	end

	def unsubscribe(unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	info_cng =
	user.info
	\|> User.Info.remove_from_subscribers(unsubscriber.ap_id)

	change(user)
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache()
	end
	end

	def block(blocker, %User{ap_id: ap_id} = 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

	blocker =
	if subscribed_to?(blocked, blocker) do
	{:ok, blocker} = unsubscribe(blocked, blocker)
	blocker
	else
	blocker
	end

	if following?(blocked, blocker) do
	unfollow(blocked, blocker)
	end

	{:ok, blocker} = update_follower_count(blocker)

	info_cng =
	blocker.info
	\|> User.Info.add_to_block(ap_id)

	cng =
	change(blocker)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

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

	def unblock(blocker, %{ap_id: ap_id}) do
	info_cng =
	blocker.info
	\|> User.Info.remove_from_block(ap_id)

	cng =
	change(blocker)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def mutes?(nil, _), do: false
	def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)

	@spec muted_notifications?(User.t() \| nil, User.t() \| map()) :: boolean()
	def muted_notifications?(nil, _), do: false

	def muted_notifications?(user, %{ap_id: ap_id}),
	do: Enum.member?(user.info.muted_notifications, ap_id)

	def blocks?(%User{} = user, %User{} = target) do
	blocks_ap_id?(user, target) \|\| blocks_domain?(user, target)
	end

	def blocks?(nil, _), do: false

	def blocks_ap_id?(%User{} = user, %User{} = target) do
	Enum.member?(user.info.blocks, target.ap_id)
	end

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

	def blocks_domain?(%User{} = user, %User{} = target) do
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.info.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, %{ap_id: ap_id}) do
	with %User{} = target <- get_cached_by_ap_id(ap_id) do
	Enum.member?(target.info.subscribers, user.ap_id)
	end
	end

	@spec muted_users(User.t()) :: [User.t()]
	def muted_users(user) do
	User.Query.build(%{ap_id: user.info.mutes, deactivated: false})
	\|> Repo.all()
	end

	@spec blocked_users(User.t()) :: [User.t()]
	def blocked_users(user) do
	User.Query.build(%{ap_id: user.info.blocks, deactivated: false})
	\|> Repo.all()
	end

	@spec subscribers(User.t()) :: [User.t()]
	def subscribers(user) do
	User.Query.build(%{ap_id: user.info.subscribers, deactivated: false})
	\|> Repo.all()
	end

	def block_domain(user, domain) do
	info_cng =
	user.info
	\|> User.Info.add_to_domain_block(domain)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def unblock_domain(user, domain) do
	info_cng =
	user.info
	\|> User.Info.remove_from_domain_block(domain)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def deactivate_async(user, status \\ true) do
	PleromaJobQueue.enqueue(:background, __MODULE__, [:deactivate_async, user, status])
	end

	def deactivate(%User{} = user, status \\ true) do
	info_cng = User.Info.set_activation_status(user.info, status)

	with {:ok, friends} <- User.get_friends(user),
	{:ok, followers} <- User.get_followers(user),
	{:ok, user} <-
	user
	\|> change()
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache() do
	Enum.each(followers, &invalidate_cache(&1))
	Enum.each(friends, &update_follower_count(&1))

	{:ok, user}
	end
	end

	def update_notification_settings(%User{} = user, settings \\ %{}) do
	info_changeset = User.Info.update_notification_settings(user.info, settings)

	change(user)
	\|> put_embed(:info, info_changeset)
	\|> update_and_set_cache()
	end

	@spec delete(User.t()) :: :ok
	def delete(%User{} = user),
	do: PleromaJobQueue.enqueue(:background, __MODULE__, [:delete, user])

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:delete, %User{} = user) do
	{:ok, _user} = ActivityPub.delete(user)

	# Remove all relationships
	{:ok, followers} = User.get_followers(user)

	Enum.each(followers, fn follower ->
	ActivityPub.unfollow(follower, user)
	User.unfollow(follower, user)
	end)

	{:ok, friends} = User.get_friends(user)

	Enum.each(friends, fn followed ->
	ActivityPub.unfollow(user, followed)
	User.unfollow(user, followed)
	end)

	delete_user_activities(user)
	invalidate_cache(user)
	Repo.delete(user)
	end

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:fetch_initial_posts, %User{} = user) do
	pages = Pleroma.Config.get!([:fetch_initial_posts, :pages])

	Enum.each(
	# Insert all the posts in reverse order, so they're in the right order on the timeline
	Enum.reverse(Utils.fetch_ordered_collection(user.info.source_data["outbox"], pages)),
	&Pleroma.Web.Federator.incoming_ap_doc/1
	)

	{:ok, user}
	end

	def perform(:deactivate_async, user, status), do: deactivate(user, status)

	@spec perform(atom(), User.t(), list()) :: list() \| {:error, any()}
	def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
	when is_list(blocked_identifiers) do
	Enum.map(
	blocked_identifiers,
	fn blocked_identifier ->
	with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
	{:ok, blocker} <- block(blocker, blocked),
	{:ok, _} <- ActivityPub.block(blocker, blocked) do
	blocked
	else
	err ->
	Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
	err
	end
	end
	)
	end

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

	@spec external_users_query() :: Ecto.Query.t()
	def external_users_query do
	User.Query.build(%{
	external: true,
	active: true,
	order_by: :id
	})
	end

	@spec external_users(keyword()) :: [User.t()]
	def external_users(opts \\ []) do
	query =
	external_users_query()
	\|> select([u], struct(u, [:id, :ap_id, :info]))

	query =
	if opts[:max_id],
	do: where(query, [u], u.id > ^opts[:max_id]),
	else: query

	query =
	if opts[:limit],
	do: limit(query, ^opts[:limit]),
	else: query

	Repo.all(query)
	end

	def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers),
	do:
	PleromaJobQueue.enqueue(:background, __MODULE__, [
	:blocks_import,
	blocker,
	blocked_identifiers
	])

	def follow_import(%User{} = follower, followed_identifiers) when is_list(followed_identifiers),
	do:
	PleromaJobQueue.enqueue(:background, __MODULE__, [
	:follow_import,
	follower,
	followed_identifiers
	])

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	ap_id
	\|> Activity.query_by_actor()
	\|> RepoStreamer.chunk_stream(50)
	\|> Stream.each(fn activities ->
	Enum.each(activities, &delete_activity(&1))
	end)
	\|> Stream.run()

	{:ok, user}
	end

	defp delete_activity(%{data: %{"type" => "Create"}} = activity) do
	activity
	\|> Object.normalize()
	\|> ActivityPub.delete()
	end

	defp delete_activity(%{data: %{"type" => "Like"}} = activity) do
	user = get_cached_by_ap_id(activity.actor)
	object = Object.normalize(activity)

	ActivityPub.unlike(user, object)
	end

	defp delete_activity(%{data: %{"type" => "Announce"}} = activity) do
	user = get_cached_by_ap_id(activity.actor)
	object = Object.normalize(activity)

	ActivityPub.unannounce(user, object)
	end

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

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

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

	def fetch_by_ap_id(ap_id) do
	ap_try = ActivityPub.make_user_from_ap_id(ap_id)

	case ap_try do
	{:ok, user} ->
	{:ok, user}

	_ ->
	case OStatus.make_user(ap_id) do
	{:ok, user} -> {:ok, user}
	_ -> {:error, "Could not fetch by AP id"}
	end
	end
	end

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

	if !is_nil(user) and !User.needs_update?(user) do
	{:ok, user}
	else
	# Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
	should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])

	resp = fetch_by_ap_id(ap_id)

	if should_fetch_initial do
	with {:ok, %User{} = user} <- resp do
	fetch_initial_posts(user)
	end
	end

	resp
	end
	end

	@doc "Creates an internal service actor by URI if missing. Optionally takes nickname for addressing."
	def get_or_create_service_actor_by_ap_id(uri, nickname \\ nil) do
	if user = get_cached_by_ap_id(uri) do
	user
	else
	changes =
	%User{info: %User.Info{}}
	\|> cast(%{}, [:ap_id, :nickname, :local])
	\|> put_change(:ap_id, uri)
	\|> put_change(:nickname, nickname)
	\|> put_change(:local, true)
	\|> put_change(:follower_address, uri <> "/followers")

	{:ok, user} = Repo.insert(changes)
	user
	end
	end

	# AP style
	def public_key_from_info(%{
	source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
	}) do
	key =
	public_key_pem
	\|> :public_key.pem_decode()
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

	# OStatus Magic Key
	def public_key_from_info(%{magic_key: magic_key}) when not is_nil(magic_key) do
	{:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
	end

	def public_key_from_info(_), do: {:error, "not found key"}

	def get_public_key_for_ap_id(ap_id) do
	with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
	{:ok, public_key} <- public_key_from_info(user.info) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

	defp blank?(""), do: nil
	defp blank?(n), do: n

	def insert_or_update_user(data) do
	data
	\|> Map.put(:name, blank?(data[:name]) \|\| data[:nickname])
	\|> remote_user_creation()
	\|> Repo.insert(on_conflict: :replace_all_except_primary_key, conflict_target: :nickname)
	\|> set_cache()
	end

	def ap_enabled?(%User{local: true}), do: true
	def ap_enabled?(%User{info: info}), do: info.ap_enabled
	def ap_enabled?(_), do: false

	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

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

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

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

	def parse_bio(_), do: ""

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

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

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

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

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

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

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

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

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

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

	updated_user
	end

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

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

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

	def full_nickname(nickname_or_mention),
	do: String.trim_leading(nickname_or_mention, "@")

	def error_user(ap_id) do
	%User{
	name: ap_id,
	ap_id: ap_id,
	info: %User.Info{},
	nickname: "erroruser@example.com",
	inserted_at: NaiveDateTime.utc_now()
	}
	end

	@spec all_superusers() :: [User.t()]
	def all_superusers do
	User.Query.build(%{super_users: true, local: true, deactivated: false})
	\|> Repo.all()
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	target.ap_id not in user.info.muted_reblogs
	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: fragment("not (?->'deactivated' @> 'true')", u.info),
	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{info: %{email_notifications: %{"digest" => false}}}, "digest", true)
	Pleroma.User{info: %{email_notifications: %{"digest" => true}}}

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{info: %{email_notifications: %{"digest" => true}}}, "digest", false)
	Pleroma.User{info: %{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
	info = Pleroma.User.Info.update_email_notifications(user.info, %{type => status})

	change(user)
	\|> put_embed(:info, info)
	\|> update_and_set_cache()
	end

	@doc """
	Set `last_digest_emailed_at` value for the user to current time
	"""
	@spec touch_last_digest_emailed_at(t()) :: t()
	def touch_last_digest_emailed_at(user) do
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	{:ok, updated_user} =
	user
	\|> change(%{last_digest_emailed_at: now})
	\|> update_and_set_cache()

	updated_user
	end

	@spec toggle_confirmation(User.t()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def toggle_confirmation(%User{} = user) do
	need_confirmation? = !user.info.confirmation_pending

	info_changeset =
	User.Info.confirmation_changeset(user.info, need_confirmation: need_confirmation?)

	user
	\|> change()
	\|> put_embed(:info, info_changeset)
	\|> update_and_set_cache()
	end

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

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

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

	def ensure_keys_present(%User{info: info} = user) do
	if info.keys do
	{:ok, user}
	else
	{:ok, pem} = Keys.generate_rsa_pem()

	user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, User.Info.set_keys(info, pem))
	\|> update_and_set_cache()
	end
	end

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

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

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

	defp put_password_hash(changeset), do: changeset

	def is_internal_user?(%User{nickname: nil}), do: true
	def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
	def is_internal_user?(_), do: false
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 1a279a7df..01052846f 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1162 +1,1173 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation
	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.WebFinger

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

	require Logger
	require Pleroma.Constants

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

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

	{recipients, to, cc}
	end

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

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

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

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

	defp check_remote_limit(_), do: true

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

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

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

	def increase_replies_count_if_reply(_create_data), do: :noop

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

	def decrease_replies_count_if_reply(_object), do: :noop

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

	def increase_poll_votes_if_vote(_create_data), do: :noop

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

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

	PleromaJobQueue.enqueue(:background, Pleroma.Web.RichMedia.Helpers, [:fetch, activity])

	Notification.create_notifications(activity)

	participations =
	activity
	\|> Conversation.create_or_bump_for()
	\|> get_participations()

	stream_out(activity)
	stream_out_participations(participations)
	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

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

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

	error ->
	{:error, error}
	end
	end

	defp get_participations({:ok, %{participations: participations}}), do: participations
	defp get_participations(_), do: []

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

	Enum.each(participations, fn participation ->
	Pleroma.Web.Streamer.stream("participation", participation)
	end)
	end

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

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

	def stream_out(activity) do
	if activity.data["type"] in ["Create", "Announce", "Delete"] do
	object = Object.normalize(activity)
	# Do not stream out poll replies
	unless object.data["type"] == "Answer" do
	Pleroma.Web.Streamer.stream("user", activity)
	Pleroma.Web.Streamer.stream("list", activity)

	if get_visibility(activity) == "public" do
	Pleroma.Web.Streamer.stream("public", activity)

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local", activity)
	end

	if activity.data["type"] in ["Create"] do
	object.data
	\|> Map.get("tag", [])
	\|> Enum.filter(fn tag -> is_bitstring(tag) end)
	\|> Enum.each(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)

	if object.data["attachment"] != [] do
	Pleroma.Web.Streamer.stream("public:media", activity)

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local:media", activity)
	end
	end
	end
	else
	if get_visibility(activity) == "direct",
	do: Pleroma.Web.Streamer.stream("direct", activity)
	end
	end
	end
	end

	def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	with create_data <-
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	_ <- increase_poll_votes_if_vote(create_data),
	# Changing note count prior to enqueuing federation task in order to avoid
	# race conditions on updating user.info
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:fake, true, activity} ->
	{:ok, activity}

	{:error, message} ->
	{:error, message}
	end
	end

	def accept(%{to: to, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def reject(%{to: to, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{
	"to" => to,
	"cc" => cc,
	"type" => "Update",
	"actor" => actor,
	"object" => object
	},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	# TODO: This is weird, maybe we shouldn't check here if we can make the activity.
	def like(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with nil <- get_existing_like(ap_id, object),
	like_data <- make_like_data(user, object, activity_id),
	{:ok, activity} <- insert(like_data, local),
	{:ok, object} <- add_like_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	%Activity{} = activity -> {:ok, activity, object}
	error -> {:error, error}
	end
	end

	def unlike(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
	unlike_data <- make_unlike_data(actor, like_activity, activity_id),
	{:ok, unlike_activity} <- insert(unlike_data, local),
	{:ok, _activity} <- Repo.delete(like_activity),
	{:ok, object} <- remove_like_from_object(like_activity, object),
	:ok <- maybe_federate(unlike_activity) do
	{:ok, unlike_activity, like_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def announce(
	%User{ap_id: _} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true,
	public \\ true
	) do
	with true <- is_public?(object),
	announce_data <- make_announce_data(user, object, activity_id, public),
	{:ok, activity} <- insert(announce_data, local),
	{:ok, object} <- add_announce_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	error -> {:error, error}
	end
	end

	def unannounce(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
	unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
	{:ok, unannounce_activity} <- insert(unannounce_data, local),
	:ok <- maybe_federate(unannounce_activity),
	{:ok, _activity} <- Repo.delete(announce_activity),
	{:ok, object} <- remove_announce_from_object(announce_activity, object) do
	{:ok, unannounce_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def follow(follower, followed, activity_id \\ nil, local \\ true) do
	with data <- make_follow_data(follower, followed, activity_id),
	{:ok, activity} <- insert(data, local),
	- :ok <- maybe_federate(activity) do
	+ :ok <- maybe_federate(activity),
	+ _ <- User.set_follow_state_cache(follower.ap_id, followed.ap_id, activity.data["state"]) do
	{:ok, activity}
	end
	end

	def unfollow(follower, followed, activity_id \\ nil, local \\ true) 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),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def delete(%User{ap_id: ap_id, follower_address: follower_address} = user) do
	with data <- %{
	"to" => [follower_address],
	"type" => "Delete",
	"actor" => ap_id,
	"object" => %{"type" => "Person", "id" => ap_id}
	},
	{:ok, activity} <- insert(data, true, true),
	:ok <- maybe_federate(activity) do
	{:ok, user}
	end
	end

	def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
	user = User.get_cached_by_ap_id(actor)
	to = (object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	with {:ok, object, activity} <- Object.delete(object),
	data <- %{
	"type" => "Delete",
	"actor" => actor,
	"object" => id,
	"to" => to,
	"deleted_activity_id" => activity && activity.id
	},
	{:ok, activity} <- insert(data, local, false),
	stream_out_participations(object, user),
	_ <- decrease_replies_count_if_reply(object),
	# Changing note count prior to enqueuing federation task in order to avoid
	# race conditions on updating user.info
	{:ok, _actor} <- decrease_note_count_if_public(user, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def block(blocker, blocked, activity_id \\ nil, local \\ true) do
	outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
	unfollow_blocked = Config.get([:activitypub, :unfollow_blocked])

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

	with true <- outgoing_blocks,
	block_data <- make_block_data(blocker, blocked, activity_id),
	{:ok, activity} <- insert(block_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	_e -> {:ok, nil}
	end
	end

	def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
	with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
	unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
	{:ok, activity} <- insert(unblock_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

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

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

	params = %{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content
	}

	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 <- maybe_federate(activity) do
	Enum.each(User.all_superusers(), fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	end
	end

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

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

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

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

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

	def fetch_public_activities(opts \\ %{}) do
	q = fetch_activities_query([Pleroma.Constants.as_public()], opts)

	q
	\|> restrict_unlisted()
	\|> Pagination.fetch_paginated(opts)
	\|> Enum.reverse()
	end

	@valid_visibilities ~w[direct unlisted public private]

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

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

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

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

	defp restrict_visibility(query, _visibility), do: query

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

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

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

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

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

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

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

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

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

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

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

	defp restrict_since(query, _), do: query

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

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

	defp restrict_tag_reject(query, _), do: query

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

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

	defp restrict_tag_all(query, _), do: query

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

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

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

	defp restrict_tag(query, _), do: query

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

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

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

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

	defp restrict_local(query, _), do: query

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

	defp restrict_actor(query, _), do: query

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

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

	defp restrict_type(query, _), do: query

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

	defp restrict_state(query, _), do: query

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

	defp restrict_favorited_by(query, _), do: query

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

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

	defp restrict_media(query, _), do: query

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

	defp restrict_replies(query, _), do: query

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

	defp restrict_reblogs(query, _), do: query

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

	defp restrict_muted(query, %{"muting_user" => %User{info: info}}) do
	mutes = info.mutes

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

	defp restrict_muted(query, _), do: query

	defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
	blocks = info.blocks \|\| []
	domain_blocks = info.domain_blocks \|\| []

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

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

	defp restrict_blocked(query, _), do: query

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

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

	defp restrict_pinned(query, _), do: query

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

	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 exclude_poll_votes(query, %{"include_poll_votes" => "true"}), do: query

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

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

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

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

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

	defp maybe_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["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

	def fetch_activities_query(recipients, opts \\ %{}) do
	config = %{
	skip_thread_containment: Config.get([:instance, :skip_thread_containment])
	}

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

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

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

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

	activity ->
	activity
	end)
	end

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

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

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

	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data =
	if opts[:actor] do
	Map.put(data, "actor", opts[:actor])
	else
	data
	end

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

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

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

	locked = data["manuallyApprovesFollowers"] \|\| false
	data = Transmogrifier.maybe_fix_user_object(data)

	user_data = %{
	ap_id: data["id"],
	info: %{
	ap_enabled: true,
	source_data: data,
	banner: banner,
	locked: locked
	},
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	following_address: data["following"],
	bio: data["summary"]
	}

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

	{:ok, user_data}
	end

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

	e ->
	{:error, e}
	end
	end

	defp maybe_update_follow_information(data) do
	with {:enabled, true} <-
	{:enabled, Pleroma.Config.get([:instance, :external_user_synchronization])},
	{:ok, info} <- fetch_follow_information_for_user(data) do
	info = Map.merge(data.info, info)
	Map.put(data, :info, info)
	else
	{:enabled, false} ->
	data

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

	data
	end
	end

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

	{:error, _} = e ->
	e

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

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

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

	def make_user_from_ap_id(ap_id) do
	if _user = User.get_cached_by_ap_id(ap_id) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	User.insert_or_update_user(data)
	else
	e -> {:error, e}
	end
	end
	end

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

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

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

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

	defmodule Pleroma.Web.ActivityPub.MRF do
	@callback filter(Map.t()) :: {:ok \| :reject, Map.t()}

	def filter(policies, %{} = object) do
	policies
	\|> Enum.reduce({:ok, object}, fn
	policy, {:ok, object} ->
	policy.filter(object)

	_, error ->
	error
	end)
	end

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

	def get_policies do
	Pleroma.Config.get([:instance, :rewrite_policy], []) \|> get_policies()
	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: ~r(^#{String.replace(domain, ".", "(.\\.)*")}$)i
	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
	+
	+ @callback describe() :: {:ok \| :error, Map.t()}
	+
	+ 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([:instance, :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()
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/anti_followbot_policy.ex b/lib/pleroma/web/activity_pub/mrf/anti_followbot_policy.ex
	index 87fa514c3..de1eb4aa5 100644
	--- a/lib/pleroma/web/activity_pub/mrf/anti_followbot_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/anti_followbot_policy.ex
	@@ -1,65 +1,68 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.AntiFollowbotPolicy do
	alias Pleroma.User

	@moduledoc "Prevent followbots from following with a bit of heuristic"

	@behaviour Pleroma.Web.ActivityPub.MRF

	# XXX: this should become User.normalize_by_ap_id() or similar, really.
	defp normalize_by_ap_id(%{"id" => id}), do: User.get_cached_by_ap_id(id)
	defp normalize_by_ap_id(uri) when is_binary(uri), do: User.get_cached_by_ap_id(uri)
	defp normalize_by_ap_id(_), do: nil

	defp score_nickname("followbot@" <> _), do: 1.0
	defp score_nickname("federationbot@" <> _), do: 1.0
	defp score_nickname("federation_bot@" <> _), do: 1.0
	defp score_nickname(_), do: 0.0

	defp score_displayname("federation bot"), do: 1.0
	defp score_displayname("federationbot"), do: 1.0
	defp score_displayname("fedibot"), do: 1.0
	defp score_displayname(_), do: 0.0

	defp determine_if_followbot(%User{nickname: nickname, name: displayname}) do
	# nickname will always be a binary string because it's generated by Pleroma.
	nick_score =
	nickname
	\|> String.downcase()
	\|> score_nickname()

	# displayname will either be a binary string or nil, if a displayname isn't set.
	name_score =
	if is_binary(displayname) do
	displayname
	\|> String.downcase()
	\|> score_displayname()
	else
	0.0
	end

	nick_score + name_score
	end

	defp determine_if_followbot(_), do: 0.0

	@impl true
	def filter(%{"type" => "Follow", "actor" => actor_id} = message) do
	%User{} = actor = normalize_by_ap_id(actor_id)

	score = determine_if_followbot(actor)

	# TODO: scan biography data for keywords and score it somehow.
	if score < 0.8 do
	{:ok, message}
	else
	{:reject, nil}
	end
	end

	@impl true
	def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/anti_link_spam_policy.ex b/lib/pleroma/web/activity_pub/mrf/anti_link_spam_policy.ex
	index 2da3eac2f..b90193ca0 100644
	--- a/lib/pleroma/web/activity_pub/mrf/anti_link_spam_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/anti_link_spam_policy.ex
	@@ -1,48 +1,54 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.AntiLinkSpamPolicy do
	alias Pleroma.User

	+ @behaviour Pleroma.Web.ActivityPub.MRF
	+
	require Logger

	# has the user successfully posted before?
	defp old_user?(%User{} = u) do
	u.info.note_count > 0 \|\| u.info.follower_count > 0
	end

	# does the post contain links?
	defp contains_links?(%{"content" => content} = _object) do
	content
	\|> Floki.filter_out("a.mention,a.hashtag,a[rel~=\"tag\"],a.zrl")
	\|> Floki.attribute("a", "href")
	\|> length() > 0
	end

	defp contains_links?(_), do: false

	+ @impl true
	def filter(%{"type" => "Create", "actor" => actor, "object" => object} = message) do
	with {:ok, %User{} = u} <- User.get_or_fetch_by_ap_id(actor),
	{:contains_links, true} <- {:contains_links, contains_links?(object)},
	{:old_user, true} <- {:old_user, old_user?(u)} do
	{:ok, message}
	else
	{:contains_links, false} ->
	{:ok, message}

	{:old_user, false} ->
	{:reject, nil}

	{:error, _} ->
	{:reject, nil}

	e ->
	Logger.warn("[MRF anti-link-spam] WTF: unhandled error #{inspect(e)}")
	{:reject, nil}
	end
	end

	# in all other cases, pass through
	def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/drop_policy.ex b/lib/pleroma/web/activity_pub/mrf/drop_policy.ex
	index b8d38aae6..f7831bc3e 100644
	--- a/lib/pleroma/web/activity_pub/mrf/drop_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/drop_policy.ex
	@@ -1,15 +1,18 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 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

	@impl true
	def filter(object) do
	Logger.info("REJECTING #{inspect(object)}")
	{:reject, object}
	end
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex b/lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex
	index 2d03df68a..3a3e72910 100644
	--- a/lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/ensure_re_prepended.ex
	@@ -1,42 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrepended do
	alias Pleroma.Object

	@moduledoc "Ensure a re: is prepended on replies to a post with a Subject"
	@behaviour Pleroma.Web.ActivityPub.MRF

	@reply_prefix Regex.compile!("^re:[[:space:]]*", [:caseless])

	def filter_by_summary(
	%{data: %{"summary" => parent_summary}} = _in_reply_to,
	%{"summary" => child_summary} = child
	)
	when not is_nil(child_summary) and byte_size(child_summary) > 0 and
	not is_nil(parent_summary) and byte_size(parent_summary) > 0 do
	if (child_summary == parent_summary and not Regex.match?(@reply_prefix, child_summary)) or
	(Regex.match?(@reply_prefix, parent_summary) &&
	Regex.replace(@reply_prefix, parent_summary, "") == child_summary) do
	Map.put(child, "summary", "re: " <> child_summary)
	else
	child
	end
	end

	def filter_by_summary(_in_reply_to, child), do: child

	def filter(%{"type" => "Create", "object" => child_object} = object) do
	child =
	child_object["inReplyTo"]
	\|> Object.normalize(child_object["inReplyTo"])
	\|> filter_by_summary(child_object)

	object = Map.put(object, "object", child)

	{:ok, object}
	end

	def filter(object), do: {:ok, object}
	+
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/hellthread_policy.ex b/lib/pleroma/web/activity_pub/mrf/hellthread_policy.ex
	index 377987cf2..b3c742954 100644
	--- a/lib/pleroma/web/activity_pub/mrf/hellthread_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/hellthread_policy.ex
	@@ -1,93 +1,97 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.HellthreadPolicy do
	alias Pleroma.User

	require Pleroma.Constants

	@moduledoc "Block messages with too much mentions (configurable)"

	@behaviour Pleroma.Web.ActivityPub.MRF

	defp delist_message(message, threshold) when threshold > 0 do
	follower_collection = User.get_cached_by_ap_id(message["actor"]).follower_address

	follower_collection? = Enum.member?(message["to"] ++ message["cc"], follower_collection)

	message =
	case get_recipient_count(message) do
	{:public, recipients}
	when follower_collection? and recipients > threshold ->
	message
	\|> Map.put("to", [follower_collection])
	\|> Map.put("cc", [Pleroma.Constants.as_public()])

	{:public, recipients} when recipients > threshold ->
	message
	\|> Map.put("to", [])
	\|> Map.put("cc", [Pleroma.Constants.as_public()])

	_ ->
	message
	end

	{:ok, message}
	end

	defp delist_message(message, _threshold), do: {:ok, message}

	defp reject_message(message, threshold) when threshold > 0 do
	with {_, recipients} <- get_recipient_count(message) do
	if recipients > threshold do
	{:reject, nil}
	else
	{:ok, message}
	end
	end
	end

	defp reject_message(message, _threshold), do: {:ok, message}

	defp get_recipient_count(message) do
	recipients = (message["to"] \|\| []) ++ (message["cc"] \|\| [])
	follower_collection = User.get_cached_by_ap_id(message["actor"]).follower_address

	if Enum.member?(recipients, Pleroma.Constants.as_public()) do
	recipients =
	recipients
	\|> List.delete(Pleroma.Constants.as_public())
	\|> List.delete(follower_collection)

	{:public, length(recipients)}
	else
	recipients =
	recipients
	\|> List.delete(follower_collection)

	{:not_public, length(recipients)}
	end
	end

	@impl true
	def filter(%{"type" => "Create"} = message) do
	reject_threshold =
	Pleroma.Config.get(
	[:mrf_hellthread, :reject_threshold],
	Pleroma.Config.get([:mrf_hellthread, :threshold])
	)

	delist_threshold = Pleroma.Config.get([:mrf_hellthread, :delist_threshold])

	with {:ok, message} <- reject_message(message, reject_threshold),
	{:ok, message} <- delist_message(message, delist_threshold) do
	{:ok, message}
	else
	_e -> {:reject, nil}
	end
	end

	@impl true
	def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe,
	+ do: {:ok, %{mrf_hellthread: Pleroma.Config.get(:mrf_hellthread) \|> Enum.into(%{})}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/keyword_policy.ex b/lib/pleroma/web/activity_pub/mrf/keyword_policy.ex
	index 4eec8b916..d6d1396bc 100644
	--- a/lib/pleroma/web/activity_pub/mrf/keyword_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/keyword_policy.ex
	@@ -1,99 +1,131 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
	require Pleroma.Constants

	@moduledoc "Reject or Word-Replace messages with a keyword or regex"

	@behaviour Pleroma.Web.ActivityPub.MRF
	defp string_matches?(string, _) when not is_binary(string) do
	false
	end

	defp string_matches?(string, pattern) when is_binary(pattern) do
	String.contains?(string, pattern)
	end

	defp string_matches?(string, pattern) do
	String.match?(string, pattern)
	end

	defp check_reject(%{"object" => %{"content" => content, "summary" => summary}} = message) do
	if Enum.any?(Pleroma.Config.get([:mrf_keyword, :reject]), fn pattern ->
	string_matches?(content, pattern) or string_matches?(summary, pattern)
	end) do
	{:reject, nil}
	else
	{:ok, message}
	end
	end

	defp check_ftl_removal(
	%{"to" => to, "object" => %{"content" => content, "summary" => summary}} = message
	) do
	if Pleroma.Constants.as_public() in to and
	Enum.any?(Pleroma.Config.get([:mrf_keyword, :federated_timeline_removal]), fn pattern ->
	string_matches?(content, pattern) or string_matches?(summary, pattern)
	end) do
	to = List.delete(to, Pleroma.Constants.as_public())
	cc = [Pleroma.Constants.as_public() \| message["cc"] \|\| []]

	message =
	message
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	{:ok, message}
	else
	{:ok, message}
	end
	end

	defp check_replace(%{"object" => %{"content" => content, "summary" => summary}} = message) do
	content =
	if is_binary(content) do
	content
	else
	""
	end

	summary =
	if is_binary(summary) do
	summary
	else
	""
	end

	{content, summary} =
	Enum.reduce(
	Pleroma.Config.get([:mrf_keyword, :replace]),
	{content, summary},
	fn {pattern, replacement}, {content_acc, summary_acc} ->
	{String.replace(content_acc, pattern, replacement),
	String.replace(summary_acc, pattern, replacement)}
	end
	)

	{:ok,
	message
	\|> put_in(["object", "content"], content)
	\|> put_in(["object", "summary"], summary)}
	end

	@impl true
	def filter(%{"type" => "Create", "object" => %{"content" => _content}} = message) do
	with {:ok, message} <- check_reject(message),
	{:ok, message} <- check_ftl_removal(message),
	{:ok, message} <- check_replace(message) do
	{:ok, message}
	else
	_e ->
	{:reject, nil}
	end
	end

	@impl true
	def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe do
	+ # This horror is needed to convert regex sigils to strings
	+ mrf_keyword =
	+ Pleroma.Config.get(:mrf_keyword, [])
	+ \|> Enum.map(fn {key, value} ->
	+ {key,
	+ Enum.map(value, fn
	+ {pattern, replacement} ->
	+ %{
	+ "pattern" =>
	+ if not is_binary(pattern) do
	+ inspect(pattern)
	+ else
	+ pattern
	+ end,
	+ "replacement" => replacement
	+ }
	+
	+ pattern ->
	+ if not is_binary(pattern) do
	+ inspect(pattern)
	+ else
	+ pattern
	+ end
	+ end)}
	+ end)
	+ \|> Enum.into(%{})
	+
	+ {:ok, %{mrf_keyword: mrf_keyword}}
	+ end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/mediaproxy_warming_policy.ex b/lib/pleroma/web/activity_pub/mrf/mediaproxy_warming_policy.ex
	index 01d21a299..a179dd54d 100644
	--- a/lib/pleroma/web/activity_pub/mrf/mediaproxy_warming_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/mediaproxy_warming_policy.ex
	@@ -1,56 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy do
	@moduledoc "Preloads any attachments in the MediaProxy cache by prefetching them"
	@behaviour Pleroma.Web.ActivityPub.MRF

	alias Pleroma.HTTP
	alias Pleroma.Web.MediaProxy

	require Logger

	@hackney_options [
	pool: :media,
	recv_timeout: 10_000
	]

	def perform(:prefetch, url) do
	Logger.info("Prefetching #{inspect(url)}")

	url
	\|> MediaProxy.url()
	\|> HTTP.get([], adapter: @hackney_options)
	end

	def perform(:preload, %{"object" => %{"attachment" => attachments}} = _message) do
	Enum.each(attachments, fn
	%{"url" => url} when is_list(url) ->
	url
	\|> Enum.each(fn
	%{"href" => href} ->
	PleromaJobQueue.enqueue(:background, __MODULE__, [:prefetch, href])

	x ->
	Logger.debug("Unhandled attachment URL object #{inspect(x)}")
	end)

	x ->
	Logger.debug("Unhandled attachment #{inspect(x)}")
	end)
	end

	@impl true
	def filter(
	%{"type" => "Create", "object" => %{"attachment" => attachments} = _object} = message
	)
	when is_list(attachments) and length(attachments) > 0 do
	PleromaJobQueue.enqueue(:background, __MODULE__, [:preload, message])

	{:ok, message}
	end

	@impl true
	def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/mention_policy.ex b/lib/pleroma/web/activity_pub/mrf/mention_policy.ex
	index 1842e1aeb..ce8bc4580 100644
	--- a/lib/pleroma/web/activity_pub/mrf/mention_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/mention_policy.ex
	@@ -1,24 +1,27 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.MentionPolicy do
	@moduledoc "Block messages which mention a user"

	@behaviour Pleroma.Web.ActivityPub.MRF

	@impl true
	def filter(%{"type" => "Create"} = message) do
	reject_actors = Pleroma.Config.get([:mrf_mention, :actors], [])
	recipients = (message["to"] \|\| []) ++ (message["cc"] \|\| [])

	if Enum.any?(recipients, fn recipient -> Enum.member?(reject_actors, recipient) end) do
	{:reject, nil}
	else
	{:ok, message}
	end
	end

	@impl true
	def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/no_placeholder_text_policy.ex b/lib/pleroma/web/activity_pub/mrf/no_placeholder_text_policy.ex
	index 86a48bda5..f67f48ab6 100644
	--- a/lib/pleroma/web/activity_pub/mrf/no_placeholder_text_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/no_placeholder_text_policy.ex
	@@ -1,22 +1,25 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.NoPlaceholderTextPolicy do
	@moduledoc "Ensure no content placeholder is present (such as the dot from mastodon)"
	@behaviour Pleroma.Web.ActivityPub.MRF

	@impl true
	def filter(
	%{
	"type" => "Create",
	"object" => %{"content" => content, "attachment" => _} = _child_object
	} = object
	)
	when content in [".", "<p>.</p>"] do
	{:ok, put_in(object, ["object", "content"], "")}
	end

	@impl true
	def filter(object), do: {:ok, object}
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/noop_policy.ex b/lib/pleroma/web/activity_pub/mrf/noop_policy.ex
	index c47cb3298..878c57925 100644
	--- a/lib/pleroma/web/activity_pub/mrf/noop_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/noop_policy.ex
	@@ -1,13 +1,16 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.NoOpPolicy do
	@moduledoc "Does nothing (lets the messages go through unmodified)"
	@behaviour Pleroma.Web.ActivityPub.MRF

	@impl true
	def filter(object) do
	{:ok, object}
	end
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/normalize_markup.ex b/lib/pleroma/web/activity_pub/mrf/normalize_markup.ex
	index c269d0f89..daa4c88ad 100644
	--- a/lib/pleroma/web/activity_pub/mrf/normalize_markup.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/normalize_markup.ex
	@@ -1,24 +1,26 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.NormalizeMarkup do
	@moduledoc "Scrub configured hypertext markup"
	alias Pleroma.HTML

	@behaviour Pleroma.Web.ActivityPub.MRF

	def filter(%{"type" => "Create", "object" => child_object} = object) do
	scrub_policy = Pleroma.Config.get([:mrf_normalize_markup, :scrub_policy])

	content =
	child_object["content"]
	\|> HTML.filter_tags(scrub_policy)

	object = put_in(object, ["object", "content"], content)

	{:ok, object}
	end

	def filter(object), do: {:ok, object}
	+
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/reject_non_public.ex b/lib/pleroma/web/activity_pub/mrf/reject_non_public.ex
	index 457b6ee10..5a809a321 100644
	--- a/lib/pleroma/web/activity_pub/mrf/reject_non_public.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/reject_non_public.ex
	@@ -1,47 +1,51 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.RejectNonPublic do
	@moduledoc "Rejects non-public (followers-only, direct) activities"

	alias Pleroma.Config
	alias Pleroma.User

	@behaviour Pleroma.Web.ActivityPub.MRF

	require Pleroma.Constants

	@impl true
	def filter(%{"type" => "Create"} = object) do
	user = User.get_cached_by_ap_id(object["actor"])

	# Determine visibility
	visibility =
	cond do
	Pleroma.Constants.as_public() in object["to"] -> "public"
	Pleroma.Constants.as_public() in object["cc"] -> "unlisted"
	user.follower_address in object["to"] -> "followers"
	true -> "direct"
	end

	policy = Config.get(:mrf_rejectnonpublic)

	cond do
	visibility in ["public", "unlisted"] ->
	{:ok, object}

	visibility == "followers" and Keyword.get(policy, :allow_followersonly) ->
	{:ok, object}

	visibility == "direct" and Keyword.get(policy, :allow_direct) ->
	{:ok, object}

	true ->
	{:reject, nil}
	end
	end

	@impl true
	def filter(object), do: {:ok, object}
	+
	+ @impl true
	+ def describe,
	+ do: {:ok, %{mrf_rejectnonpublic: Pleroma.Config.get(:mrf_rejectnonpublic) \|> Enum.into(%{})}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/simple_policy.ex b/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	index f266457e3..8aa6852f0 100644
	--- a/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	@@ -1,180 +1,192 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicy do
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	@moduledoc "Filter activities depending on their origin instance"
	@behaviour MRF

	require Pleroma.Constants

	defp check_accept(%{host: actor_host} = _actor_info, object) do
	accepts =
	Pleroma.Config.get([:mrf_simple, :accept])
	\|> MRF.subdomains_regex()

	cond do
	accepts == [] -> {:ok, object}
	actor_host == Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host]) -> {:ok, object}
	MRF.subdomain_match?(accepts, actor_host) -> {:ok, object}
	true -> {:reject, nil}
	end
	end

	defp check_reject(%{host: actor_host} = _actor_info, object) do
	rejects =
	Pleroma.Config.get([:mrf_simple, :reject])
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(rejects, actor_host) do
	{:reject, nil}
	else
	{:ok, object}
	end
	end

	defp check_media_removal(
	%{host: actor_host} = _actor_info,
	%{"type" => "Create", "object" => %{"attachment" => child_attachment}} = object
	)
	when length(child_attachment) > 0 do
	media_removal =
	Pleroma.Config.get([:mrf_simple, :media_removal])
	\|> MRF.subdomains_regex()

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

	{:ok, object}
	end

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

	defp check_media_nsfw(
	%{host: actor_host} = _actor_info,
	%{
	"type" => "Create",
	"object" => child_object
	} = object
	) do
	media_nsfw =
	Pleroma.Config.get([:mrf_simple, :media_nsfw])
	\|> MRF.subdomains_regex()

	object =
	if MRF.subdomain_match?(media_nsfw, actor_host) do
	tags = (child_object["tag"] \|\| []) ++ ["nsfw"]
	child_object = Map.put(child_object, "tag", tags)
	child_object = Map.put(child_object, "sensitive", true)
	Map.put(object, "object", child_object)
	else
	object
	end

	{:ok, object}
	end

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

	defp check_ftl_removal(%{host: actor_host} = _actor_info, object) do
	timeline_removal =
	Pleroma.Config.get([:mrf_simple, :federated_timeline_removal])
	\|> MRF.subdomains_regex()

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

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

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

	{:ok, object}
	end

	defp check_report_removal(%{host: actor_host} = _actor_info, %{"type" => "Flag"} = object) do
	report_removal =
	Pleroma.Config.get([:mrf_simple, :report_removal])
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(report_removal, actor_host) do
	{:reject, nil}
	else
	{:ok, object}
	end
	end

	defp check_report_removal(_actor_info, object), do: {:ok, object}

	defp check_avatar_removal(%{host: actor_host} = _actor_info, %{"icon" => _icon} = object) do
	avatar_removal =
	Pleroma.Config.get([:mrf_simple, :avatar_removal])
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(avatar_removal, actor_host) do
	{:ok, Map.delete(object, "icon")}
	else
	{:ok, object}
	end
	end

	defp check_avatar_removal(_actor_info, object), do: {:ok, object}

	defp check_banner_removal(%{host: actor_host} = _actor_info, %{"image" => _image} = object) do
	banner_removal =
	Pleroma.Config.get([:mrf_simple, :banner_removal])
	\|> MRF.subdomains_regex()

	if MRF.subdomain_match?(banner_removal, actor_host) do
	{:ok, Map.delete(object, "image")}
	else
	{:ok, object}
	end
	end

	defp check_banner_removal(_actor_info, object), do: {:ok, object}

	@impl true
	def filter(%{"actor" => actor} = object) do
	actor_info = URI.parse(actor)

	with {:ok, object} <- check_accept(actor_info, object),
	{:ok, object} <- check_reject(actor_info, object),
	{:ok, object} <- check_media_removal(actor_info, object),
	{:ok, object} <- check_media_nsfw(actor_info, object),
	{:ok, object} <- check_ftl_removal(actor_info, object),
	{:ok, object} <- check_report_removal(actor_info, object) do
	{:ok, object}
	else
	_e -> {:reject, nil}
	end
	end

	def filter(%{"id" => actor, "type" => obj_type} = object)
	when obj_type in ["Application", "Group", "Organization", "Person", "Service"] do
	actor_info = URI.parse(actor)

	with {:ok, object} <- check_avatar_removal(actor_info, object),
	{:ok, object} <- check_banner_removal(actor_info, object) do
	{:ok, object}
	else
	_e -> {:reject, nil}
	end
	end

	def filter(object), do: {:ok, object}
	+
	+ @impl true
	+ def describe do
	+ exclusions = Pleroma.Config.get([:instance, :mrf_transparency_exclusions])
	+
	+ mrf_simple =
	+ Pleroma.Config.get(:mrf_simple)
	+ \|> Enum.map(fn {k, v} -> {k, Enum.reject(v, fn v -> v in exclusions end)} end)
	+ \|> Enum.into(%{})
	+
	+ {:ok, %{mrf_simple: mrf_simple}}
	+ end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/subchain_policy.ex b/lib/pleroma/web/activity_pub/mrf/subchain_policy.ex
	index 765704389..566c1e191 100644
	--- a/lib/pleroma/web/activity_pub/mrf/subchain_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/subchain_policy.ex
	@@ -1,40 +1,43 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.SubchainPolicy do
	alias Pleroma.Config
	alias Pleroma.Web.ActivityPub.MRF

	require Logger

	@behaviour MRF

	defp lookup_subchain(actor) do
	with matches <- Config.get([:mrf_subchain, :match_actor]),
	{match, subchain} <- Enum.find(matches, fn {k, _v} -> String.match?(actor, k) end) do
	{:ok, match, subchain}
	else
	_e -> {:error, :notfound}
	end
	end

	@impl true
	def filter(%{"actor" => actor} = message) do
	with {:ok, match, subchain} <- lookup_subchain(actor) do
	Logger.debug(
	"[SubchainPolicy] Matched #{actor} against #{inspect(match)} with subchain #{
	inspect(subchain)
	}"
	)

	subchain
	\|> MRF.filter(message)
	else
	_e -> {:ok, message}
	end
	end

	@impl true
	def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/tag_policy.ex b/lib/pleroma/web/activity_pub/mrf/tag_policy.ex
	index 70edf4f7f..c1801d2ec 100644
	--- a/lib/pleroma/web/activity_pub/mrf/tag_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/tag_policy.ex
	@@ -1,168 +1,171 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.TagPolicy do
	alias Pleroma.User
	@behaviour Pleroma.Web.ActivityPub.MRF
	@moduledoc """
	Apply policies based on user tags

	This policy applies policies on a user activities depending on their tags
	on your instance.

	- `mrf_tag:media-force-nsfw`: Mark as sensitive on presence of attachments
	- `mrf_tag:media-strip`: Remove attachments
	- `mrf_tag:force-unlisted`: Mark as unlisted (removes from the federated timeline)
	- `mrf_tag:sandbox`: Remove from public (local and federated) timelines
	- `mrf_tag:disable-remote-subscription`: Reject non-local follow requests
	- `mrf_tag:disable-any-subscription`: Reject any follow requests
	"""

	require Pleroma.Constants

	defp get_tags(%User{tags: tags}) when is_list(tags), do: tags
	defp get_tags(_), do: []

	defp process_tag(
	"mrf_tag:media-force-nsfw",
	%{
	"type" => "Create",
	"object" => %{"attachment" => child_attachment} = object
	} = message
	)
	when length(child_attachment) > 0 do
	tags = (object["tag"] \|\| []) ++ ["nsfw"]

	object =
	object
	\|> Map.put("tag", tags)
	\|> Map.put("sensitive", true)

	message = Map.put(message, "object", object)

	{:ok, message}
	end

	defp process_tag(
	"mrf_tag:media-strip",
	%{
	"type" => "Create",
	"object" => %{"attachment" => child_attachment} = object
	} = message
	)
	when length(child_attachment) > 0 do
	object = Map.delete(object, "attachment")
	message = Map.put(message, "object", object)

	{:ok, message}
	end

	defp process_tag(
	"mrf_tag:force-unlisted",
	%{
	"type" => "Create",
	"to" => to,
	"cc" => cc,
	"actor" => actor,
	"object" => object
	} = message
	) do
	user = User.get_cached_by_ap_id(actor)

	if Enum.member?(to, Pleroma.Constants.as_public()) do
	to = List.delete(to, Pleroma.Constants.as_public()) ++ [user.follower_address]
	cc = List.delete(cc, user.follower_address) ++ [Pleroma.Constants.as_public()]

	object =
	object
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	message =
	message
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)
	\|> Map.put("object", object)

	{:ok, message}
	else
	{:ok, message}
	end
	end

	defp process_tag(
	"mrf_tag:sandbox",
	%{
	"type" => "Create",
	"to" => to,
	"cc" => cc,
	"actor" => actor,
	"object" => object
	} = message
	) do
	user = User.get_cached_by_ap_id(actor)

	if Enum.member?(to, Pleroma.Constants.as_public()) or
	Enum.member?(cc, Pleroma.Constants.as_public()) do
	to = List.delete(to, Pleroma.Constants.as_public()) ++ [user.follower_address]
	cc = List.delete(cc, Pleroma.Constants.as_public())

	object =
	object
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	message =
	message
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)
	\|> Map.put("object", object)

	{:ok, message}
	else
	{:ok, message}
	end
	end

	defp process_tag(
	"mrf_tag:disable-remote-subscription",
	%{"type" => "Follow", "actor" => actor} = message
	) do
	user = User.get_cached_by_ap_id(actor)

	if user.local == true do
	{:ok, message}
	else
	{:reject, nil}
	end
	end

	defp process_tag("mrf_tag:disable-any-subscription", %{"type" => "Follow"}),
	do: {:reject, nil}

	defp process_tag(_, message), do: {:ok, message}

	def filter_message(actor, message) do
	User.get_cached_by_ap_id(actor)
	\|> get_tags()
	\|> Enum.reduce({:ok, message}, fn
	tag, {:ok, message} ->
	process_tag(tag, message)

	_, error ->
	error
	end)
	end

	@impl true
	def filter(%{"object" => target_actor, "type" => "Follow"} = message),
	do: filter_message(target_actor, message)

	@impl true
	def filter(%{"actor" => actor, "type" => "Create"} = message),
	do: filter_message(actor, message)

	@impl true
	def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe, do: {:ok, %{}}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/user_allowlist_policy.ex b/lib/pleroma/web/activity_pub/mrf/user_allowlist_policy.ex
	index e35d2c422..7389d6a96 100644
	--- a/lib/pleroma/web/activity_pub/mrf/user_allowlist_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/user_allowlist_policy.ex
	@@ -1,35 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.MRF.UserAllowListPolicy do
	alias Pleroma.Config

	@moduledoc "Accept-list of users from specified instances"
	@behaviour Pleroma.Web.ActivityPub.MRF

	defp filter_by_list(object, []), do: {:ok, object}

	defp filter_by_list(%{"actor" => actor} = object, allow_list) do
	if actor in allow_list do
	{:ok, object}
	else
	{:reject, nil}
	end
	end

	@impl true
	def filter(%{"actor" => actor} = object) do
	actor_info = URI.parse(actor)

	allow_list =
	Config.get(
	[:mrf_user_allowlist, String.to_atom(actor_info.host)],
	[]
	)

	filter_by_list(object, allow_list)
	end

	def filter(object), do: {:ok, object}
	+
	+ @impl true
	+ def describe do
	+ mrf_user_allowlist =
	+ Config.get([:mrf_user_allowlist], [])
	+ \|> Enum.into(%{}, fn {k, v} -> {k, length(v)} end)
	+
	+ {:ok, %{mrf_user_allowlist: mrf_user_allowlist}}
	+ end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/vocabulary_policy.ex b/lib/pleroma/web/activity_pub/mrf/vocabulary_policy.ex
	new file mode 100644
	index 000000000..4eaea00d8
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/mrf/vocabulary_policy.ex
	@@ -0,0 +1,37 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicy do
	+ @moduledoc "Filter messages which belong to certain activity vocabularies"
	+
	+ @behaviour Pleroma.Web.ActivityPub.MRF
	+
	+ def filter(%{"type" => "Undo", "object" => child_message} = message) do
	+ with {:ok, _} <- filter(child_message) do
	+ {:ok, message}
	+ else
	+ {:reject, nil} ->
	+ {:reject, nil}
	+ end
	+ end
	+
	+ def filter(%{"type" => message_type} = message) do
	+ with accepted_vocabulary <- Pleroma.Config.get([:mrf_vocabulary, :accept]),
	+ rejected_vocabulary <- Pleroma.Config.get([:mrf_vocabulary, :reject]),
	+ true <-
	+ length(accepted_vocabulary) == 0 \|\| Enum.member?(accepted_vocabulary, message_type),
	+ false <-
	+ length(rejected_vocabulary) > 0 && Enum.member?(rejected_vocabulary, message_type),
	+ {:ok, _} <- filter(message["object"]) do
	+ {:ok, message}
	+ else
	+ _ -> {:reject, nil}
	+ end
	+ end
	+
	+ def filter(message), do: {:ok, message}
	+
	+ def describe,
	+ do: {:ok, %{mrf_vocabulary: Pleroma.Config.get(:mrf_vocabulary) \|> Enum.into(%{})}}
	+end
	diff --git a/lib/pleroma/web/activity_pub/publisher.ex b/lib/pleroma/web/activity_pub/publisher.ex
	index 46edab0bd..262529b84 100644
	--- a/lib/pleroma/web/activity_pub/publisher.ex
	+++ b/lib/pleroma/web/activity_pub/publisher.ex
	@@ -1,245 +1,246 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Publisher do
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier

	require Pleroma.Constants

	import Pleroma.Web.ActivityPub.Visibility

	@behaviour Pleroma.Web.Federator.Publisher

	require Logger

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

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

	@doc """
	Publish a single message to a peer. Takes a struct with the following
	parameters set:

	* `inbox`: the inbox to publish to
	* `json`: the JSON message body representing the ActivityPub message
	* `actor`: the actor which is signing the message
	* `id`: the ActivityStreams URI of the message
	"""
	def publish_one(%{inbox: inbox, json: json, actor: %User{} = actor, id: id} = params) do
	Logger.info("Federating #{id} to #{inbox}")
	- host = URI.parse(inbox).host
	+ %{host: host, path: path} = URI.parse(inbox)

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

	date =
	NaiveDateTime.utc_now()
	\|> Timex.format!("{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} GMT")

	signature =
	Pleroma.Signature.sign(actor, %{
	+ "(request-target)": "post #{path}",
	host: host,
	"content-length": byte_size(json),
	digest: digest,
	date: date
	})

	with {:ok, %{status: code}} when code in 200..299 <-
	result =
	HTTP.post(
	inbox,
	json,
	[
	{"Content-Type", "application/activity+json"},
	{"Date", date},
	{"signature", signature},
	{"digest", digest}
	]
	) do
	if !Map.has_key?(params, :unreachable_since) \|\| params[:unreachable_since],
	do: Instances.set_reachable(inbox)

	result
	else
	{_post_result, response} ->
	unless params[:unreachable_since], do: Instances.set_unreachable(inbox)
	{:error, response}
	end
	end

	defp should_federate?(inbox, public) do
	if public do
	true
	else
	%{host: host} = URI.parse(inbox)

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

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

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

	Pleroma.Web.Salmon.remote_users(actor, activity) ++ followers
	end

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

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

	defp maybe_use_sharedinbox(%User{info: %{source_data: data}}),
	do: (is_map(data["endpoints"]) && Map.get(data["endpoints"], "sharedInbox")) \|\| data["inbox"]

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

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

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

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

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

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

	true ->
	data["inbox"]
	end
	end

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

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

	recipients = recipients(actor, activity)

	recipients
	\|> Enum.filter(&User.ap_enabled?/1)
	\|> Enum.map(fn %{info: %{source_data: data}} -> data["inbox"] end)
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	\|> Instances.filter_reachable()
	\|> Enum.each(fn {inbox, unreachable_since} ->
	%User{ap_id: ap_id} =
	Enum.find(recipients, fn %{info: %{source_data: data}} -> data["inbox"] == inbox end)

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

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

	Pleroma.Web.Federator.Publisher.enqueue_one(__MODULE__, %{
	inbox: inbox,
	json: json,
	actor: actor,
	id: activity.data["id"],
	unreachable_since: unreachable_since
	})
	end)
	end

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

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

	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
	json = Jason.encode!(data)

	recipients(actor, activity)
	\|> Enum.filter(fn user -> User.ap_enabled?(user) end)
	\|> Enum.map(fn %User{} = user ->
	determine_inbox(activity, user)
	end)
	\|> Enum.uniq()
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	\|> Instances.filter_reachable()
	\|> Enum.each(fn {inbox, unreachable_since} ->
	Pleroma.Web.Federator.Publisher.enqueue_one(
	__MODULE__,
	%{
	inbox: inbox,
	json: json,
	actor: actor,
	id: activity.data["id"],
	unreachable_since: unreachable_since
	}
	)
	end)
	end

	def gather_webfinger_links(%User{} = user) do
	[
	%{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
	%{
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"href" => user.ap_id
	}
	]
	end

	def gather_nodeinfo_protocol_names, do: ["activitypub"]
	end
	diff --git a/lib/pleroma/web/activity_pub/relay.ex b/lib/pleroma/web/activity_pub/relay.ex
	index 1ebfcdd86..5f18cc64a 100644
	--- a/lib/pleroma/web/activity_pub/relay.ex
	+++ b/lib/pleroma/web/activity_pub/relay.ex
	@@ -1,53 +1,66 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Relay do
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	require Logger

	def get_actor do
	"#{Pleroma.Web.Endpoint.url()}/relay"
	\|> User.get_or_create_service_actor_by_ap_id()
	end

	+ @spec follow(String.t()) :: {:ok, Activity.t()} \| {:error, any()}
	def follow(target_instance) do
	with %User{} = local_user <- get_actor(),
	{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_instance),
	{:ok, activity} <- ActivityPub.follow(local_user, target_user) do
	Logger.info("relay: followed instance: #{target_instance}; id=#{activity.data["id"]}")
	{:ok, activity}
	else
	+ {:error, _} = error ->
	+ Logger.error("error: #{inspect(error)}")
	+ error
	+
	e ->
	Logger.error("error: #{inspect(e)}")
	{:error, e}
	end
	end

	+ @spec unfollow(String.t()) :: {:ok, Activity.t()} \| {:error, any()}
	def unfollow(target_instance) do
	with %User{} = local_user <- get_actor(),
	{:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_instance),
	{:ok, activity} <- ActivityPub.unfollow(local_user, target_user) do
	Logger.info("relay: unfollowed instance: #{target_instance}: id=#{activity.data["id"]}")
	{:ok, activity}
	else
	+ {:error, _} = error ->
	+ Logger.error("error: #{inspect(error)}")
	+ error
	+
	e ->
	Logger.error("error: #{inspect(e)}")
	{:error, e}
	end
	end

	+ @spec publish(any()) :: {:ok, Activity.t(), Object.t()} \| {:error, any()}
	def publish(%Activity{data: %{"type" => "Create"}} = activity) do
	with %User{} = user <- get_actor(),
	%Object{} = object <- Object.normalize(activity) do
	ActivityPub.announce(user, object, nil, true, false)
	else
	- e -> Logger.error("error: #{inspect(e)}")
	+ e ->
	+ Logger.error("error: #{inspect(e)}")
	+ {:error, inspect(e)}
	end
	end

	- def publish(_), do: nil
	+ def publish(_), do: {:error, "Not implemented"}
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index fc5305c58..1c3058658 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,797 +1,802 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Ecto.Changeset
	alias Ecto.UUID
	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@supported_object_types ["Article", "Note", "Video", "Page", "Question", "Answer"]
	@supported_report_states ~w(open closed resolved)
	@valid_visibilities ~w(public unlisted private direct)

	# Some implementations send the actor URI as the actor field, others send the entire actor object,
	# so figure out what the actor's URI is based on what we have.
	def get_ap_id(%{"id" => id} = _), do: id
	def get_ap_id(id), do: id

	def normalize_params(params) do
	Map.put(params, "actor", get_ap_id(params["actor"]))
	end

	def determine_explicit_mentions(%{"tag" => tag} = _object) when is_list(tag) do
	tag
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	end

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

	def determine_explicit_mentions(_), do: []

	defp recipient_in_collection(ap_id, coll) when is_binary(coll), do: ap_id == coll
	defp recipient_in_collection(ap_id, coll) when is_list(coll), do: ap_id in coll
	defp recipient_in_collection(_, _), do: false

	def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params) do
	cond do
	recipient_in_collection(ap_id, params["to"]) ->
	true

	recipient_in_collection(ap_id, params["cc"]) ->
	true

	recipient_in_collection(ap_id, params["bto"]) ->
	true

	recipient_in_collection(ap_id, params["bcc"]) ->
	true

	# if the message is unaddressed at all, then assume it is directly addressed
	# to the recipient
	!params["to"] && !params["cc"] && !params["bto"] && !params["bcc"] ->
	true

	# if the message is sent from somebody the user is following, then assume it
	# is addressed to the recipient
	User.following?(recipient, actor) ->
	true

	true ->
	false
	end
	end

	defp extract_list(target) when is_binary(target), do: [target]
	defp extract_list(lst) when is_list(lst), do: lst
	defp extract_list(_), do: []

	def maybe_splice_recipient(ap_id, params) do
	need_splice =
	!recipient_in_collection(ap_id, params["to"]) &&
	!recipient_in_collection(ap_id, params["cc"])

	cc_list = extract_list(params["cc"])

	if need_splice do
	params
	\|> Map.put("cc", [ap_id \| cc_list])
	else
	params
	end
	end

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"#{Web.base_url()}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	]
	}
	end

	def make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601()
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Helpers.o_status_url(Endpoint, :object, UUID.generate())
	end

	def generate_id(type) do
	"#{Web.base_url()}/#{type}/#{UUID.generate()}"
	end

	def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
	fake_create_activity = %{
	"to" => object["to"],
	"cc" => object["cc"],
	"type" => "Create",
	"object" => object
	}

	Notification.get_notified_from_activity(%Activity{data: fake_create_activity}, false)
	end

	def get_notified_from_object(object) do
	Notification.get_notified_from_activity(%Activity{data: object}, false)
	end

	def create_context(context) do
	context = context \|\| generate_id("contexts")

	# Ecto has problems accessing the constraint inside the jsonb,
	# so we explicitly check for the existed object before insert
	object = Object.get_cached_by_ap_id(context)

	with true <- is_nil(object),
	changeset <- Object.context_mapping(context),
	{:ok, inserted_object} <- Repo.insert(changeset) do
	inserted_object
	else
	_ ->
	object
	end
	end

	@doc """
	Enqueues an activity for federation if it's local
	"""
	def maybe_federate(%Activity{local: true} = activity) do
	if Pleroma.Config.get!([:instance, :federating]) do
	priority =
	case activity.data["type"] do
	"Delete" -> 10
	"Create" -> 1
	_ -> 5
	end

	Pleroma.Web.Federator.publish(activity, priority)
	end

	:ok
	end

	def maybe_federate(_), do: :ok

	@doc """
	Adds an id and a published data if they aren't there,
	also adds it to an included object
	"""
	def lazy_put_activity_defaults(map, fake \\ false) do
	map =
	unless fake do
	%{data: %{"id" => context}, id: context_id} = create_context(map["context"])

	map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", context)
	\|> Map.put_new("context_id", context_id)
	else
	map
	\|> Map.put_new("id", "pleroma:fakeid")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", "pleroma:fakecontext")
	\|> Map.put_new("context_id", -1)
	end

	if is_map(map["object"]) do
	object = lazy_put_object_defaults(map["object"], map, fake)
	%{map \| "object" => object}
	else
	map
	end
	end

	@doc """
	Adds an id and published date if they aren't there.
	"""
	def lazy_put_object_defaults(map, activity \\ %{}, fake)

	def lazy_put_object_defaults(map, activity, true = _fake) do
	map
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("id", "pleroma:fake_object_id")
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("fake", true)
	\|> Map.put_new("context_id", activity["context_id"])
	end

	def lazy_put_object_defaults(map, activity, _fake) do
	map
	\|> Map.put_new_lazy("id", &generate_object_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("context_id", activity["context_id"])
	end

	@doc """
	Inserts a full object if it is contained in an activity.
	"""
	def insert_full_object(%{"object" => %{"type" => type} = object_data} = map)
	when is_map(object_data) and type in @supported_object_types do
	with {:ok, object} <- Object.create(object_data) do
	map =
	map
	\|> Map.put("object", object.data["id"])

	{:ok, map, object}
	end
	end

	def insert_full_object(map), do: {:ok, map, nil}

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	where: fragment("(?)->>'actor' = ?", activity.data, ^actor),
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Like'", activity.data)
	)

	Repo.one(query)
	end

	@doc """
	Returns like activities targeting an object
	"""
	def get_object_likes(%{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Like'", activity.data)
	)

	Repo.all(query)
	end

	def make_like_data(
	%User{ap_id: ap_id} = actor,
	%{data: %{"actor" => object_actor_id, "id" => id}} = object,
	activity_id
	) do
	object_actor = User.get_cached_by_ap_id(object_actor_id)

	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	data = %{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def update_element_in_object(property, element, object) do
	with new_data <-
	object.data
	\|> Map.put("#{property}_count", length(element))
	\|> Map.put("#{property}s", element),
	changeset <- Changeset.change(object, data: new_data),
	{:ok, object} <- Object.update_and_set_cache(changeset) do
	{:ok, object}
	end
	end

	def update_likes_in_object(likes, object) do
	update_element_in_object("like", likes, object)
	end

	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

	with likes <- [actor \| likes] \|> Enum.uniq() do
	update_likes_in_object(likes, object)
	end
	end

	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

	with likes <- likes \|> List.delete(actor) do
	update_likes_in_object(likes, object)
	end
	end

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	def update_follow_state_for_all(
	%Activity{data: %{"actor" => actor, "object" => object}} = activity,
	state
	) do
	try do
	Ecto.Adapters.SQL.query!(
	Repo,
	"UPDATE activities SET data = jsonb_set(data, '{state}', $1) WHERE data->>'type' = 'Follow' AND data->>'actor' = $2 AND data->>'object' = $3 AND data->>'state' = 'pending'",
	[state, actor, object]
	)

	+ User.set_follow_state_cache(actor, object, state)
	activity = Activity.get_by_id(activity.id)
	{:ok, activity}
	rescue
	e ->
	{:error, e}
	end
	end

	- def update_follow_state(%Activity{} = activity, state) do
	+ def update_follow_state(
	+ %Activity{data: %{"actor" => actor, "object" => object}} = activity,
	+ state
	+ ) do
	with new_data <-
	activity.data
	\|> Map.put("state", state),
	changeset <- Changeset.change(activity, data: new_data),
	- {:ok, activity} <- Repo.update(changeset) do
	+ {:ok, activity} <- Repo.update(changeset),
	+ _ <- User.set_follow_state_cache(actor, object, state) do
	{:ok, activity}
	end
	end

	@doc """
	Makes a follow activity data for the given follower and followed
	"""
	def make_follow_data(
	%User{ap_id: follower_id},
	%User{ap_id: followed_id} = _followed,
	activity_id
	) do
	data = %{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"cc" => [Pleroma.Constants.as_public()],
	"object" => followed_id,
	"state" => "pending"
	}

	data = if activity_id, do: Map.put(data, "id", activity_id), else: data

	data
	end

	def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
	query =
	from(
	activity in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Follow'",
	activity.data
	),
	where: activity.actor == ^follower_id,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^followed_id
	),
	order_by: [fragment("? desc nulls last", activity.id)],
	limit: 1
	)

	Repo.one(query)
	end

	#### Announce-related helpers

	@doc """
	Retruns an existing announce activity if the notice has already been announced
	"""
	def get_existing_announce(actor, %{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	where: activity.actor == ^actor,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Announce'", activity.data)
	)

	Repo.one(query)
	end

	@doc """
	Make announce activity data for the given actor and object
	"""
	# for relayed messages, we only want to send to subscribers
	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	false
	) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address],
	"cc" => [],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	true
	) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	@doc """
	Make unannounce activity data for the given actor and object
	"""
	def make_unannounce_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context}} = activity,
	activity_id
	) do
	data = %{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, activity.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => context
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_unlike_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context}} = activity,
	activity_id
	) do
	data = %{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, activity.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => context
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def add_announce_to_object(
	%Activity{
	data: %{"actor" => actor, "cc" => [Pleroma.Constants.as_public()]}
	},
	object
	) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

	with announcements <- [actor \| announcements] \|> Enum.uniq() do
	update_element_in_object("announcement", announcements, object)
	end
	end

	def add_announce_to_object(_, object), do: {:ok, object}

	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

	with announcements <- announcements \|> List.delete(actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	#### Unfollow-related helpers

	def make_unfollow_data(follower, followed, follow_activity, activity_id) do
	data = %{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	"object" => follow_activity.data
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Block-related helpers
	def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	query =
	from(
	activity in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Block'",
	activity.data
	),
	where: activity.actor == ^blocker_id,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^blocked_id
	),
	order_by: [fragment("? desc nulls last", activity.id)],
	limit: 1
	)

	Repo.one(query)
	end

	def make_block_data(blocker, blocked, activity_id) do
	data = %{
	"type" => "Block",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => blocked.ap_id
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_unblock_data(blocker, blocked, block_activity, activity_id) do
	data = %{
	"type" => "Undo",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => block_activity.data
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Create-related helpers

	def make_create_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	#### Flag-related helpers

	def make_flag_data(params, additional) do
	status_ap_ids =
	Enum.map(params.statuses \|\| [], fn
	%Activity{} = act -> act.data["id"]
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end)

	object = [params.account.ap_id] ++ status_ap_ids

	%{
	"type" => "Flag",
	"actor" => params.actor.ap_id,
	"content" => params.content,
	"object" => object,
	"context" => params.context,
	"state" => "open"
	}
	\|> Map.merge(additional)
	end

	@doc """
	Fetches the OrderedCollection/OrderedCollectionPage from `from`, limiting the amount of pages fetched after
	the first one to `pages_left` pages.
	If the amount of pages is higher than the collection has, it returns whatever was there.
	"""
	def fetch_ordered_collection(from, pages_left, acc \\ []) do
	with {:ok, response} <- Tesla.get(from),
	{:ok, collection} <- Jason.decode(response.body) do
	case collection["type"] do
	"OrderedCollection" ->
	# If we've encountered the OrderedCollection and not the page,
	# just call the same function on the page address
	fetch_ordered_collection(collection["first"], pages_left)

	"OrderedCollectionPage" ->
	if pages_left > 0 do
	# There are still more pages
	if Map.has_key?(collection, "next") do
	# There are still more pages, go deeper saving what we have into the accumulator
	fetch_ordered_collection(
	collection["next"],
	pages_left - 1,
	acc ++ collection["orderedItems"]
	)
	else
	# No more pages left, just return whatever we already have
	acc ++ collection["orderedItems"]
	end
	else
	# Got the amount of pages needed, add them all to the accumulator
	acc ++ collection["orderedItems"]
	end

	_ ->
	{:error, "Not an OrderedCollection or OrderedCollectionPage"}
	end
	end
	end

	#### Report-related helpers

	def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
	with new_data <- Map.put(activity.data, "state", state),
	changeset <- Changeset.change(activity, data: new_data),
	{:ok, activity} <- Repo.update(changeset) do
	{:ok, activity}
	end
	end

	def update_report_state(_, _), do: {:error, "Unsupported state"}

	def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
	[to, cc, recipients] =
	activity
	\|> get_updated_targets(visibility)
	\|> Enum.map(&Enum.uniq/1)

	object_data =
	activity.object.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	{:ok, object} =
	activity.object
	\|> Object.change(%{data: object_data})
	\|> Object.update_and_set_cache()

	activity_data =
	activity.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	activity
	\|> Map.put(:object, object)
	\|> Activity.change(%{data: activity_data, recipients: recipients})
	\|> Repo.update()
	end

	def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}

	defp get_updated_targets(
	%Activity{data: %{"to" => to} = data, recipients: recipients},
	visibility
	) do
	cc = Map.get(data, "cc", [])
	follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
	public = Pleroma.Constants.as_public()

	case visibility do
	"public" ->
	to = [public \| List.delete(to, follower_address)]
	cc = [follower_address \| List.delete(cc, public)]
	recipients = [public \| recipients]
	[to, cc, recipients]

	"private" ->
	to = [follower_address \| List.delete(to, public)]
	cc = List.delete(cc, public)
	recipients = List.delete(recipients, public)
	[to, cc, recipients]

	"unlisted" ->
	to = [follower_address \| List.delete(to, public)]
	cc = [public \| List.delete(cc, follower_address)]
	recipients = recipients ++ [follower_address, public]
	[to, cc, recipients]

	_ ->
	[to, cc, recipients]
	end
	end

	def get_existing_votes(actor, %{data: %{"id" => id}}) do
	query =
	from(
	[activity, object: object] in Activity.with_preloaded_object(Activity),
	where: fragment("(?)->>'type' = 'Create'", activity.data),
	where: fragment("(?)->>'actor' = ?", activity.data, ^actor),
	where:
	fragment(
	"(?)->>'inReplyTo' = ?",
	object.data,
	^to_string(id)
	),
	where: fragment("(?)->>'type' = 'Answer'", object.data)
	)

	Repo.all(query)
	end
	end
	diff --git a/lib/pleroma/web/chat_channel.ex b/lib/pleroma/web/chat_channel.ex
	index f63f4bda1..b543909f1 100644
	--- a/lib/pleroma/web/chat_channel.ex
	+++ b/lib/pleroma/web/chat_channel.ex
	@@ -1,54 +1,56 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ChatChannel do
	use Phoenix.Channel
	alias Pleroma.User
	alias Pleroma.Web.ChatChannel.ChatChannelState

	def join("chat:public", _message, socket) do
	send(self(), :after_join)
	{:ok, socket}
	end

	def handle_info(:after_join, socket) do
	push(socket, "messages", %{messages: ChatChannelState.messages()})
	{:noreply, socket}
	end

	def handle_in("new_msg", %{"text" => text}, %{assigns: %{user_name: user_name}} = socket) do
	text = String.trim(text)

	if String.length(text) > 0 do
	author = User.get_cached_by_nickname(user_name)
	author = Pleroma.Web.MastodonAPI.AccountView.render("account.json", user: author)
	message = ChatChannelState.add_message(%{text: text, author: author})

	broadcast!(socket, "new_msg", message)
	end

	{:noreply, socket}
	end
	end

	defmodule Pleroma.Web.ChatChannel.ChatChannelState do
	+ use Agent
	+
	@max_messages 20

	- def start_link do
	+ def start_link(_) do
	Agent.start_link(fn -> %{max_id: 1, messages: []} end, name: __MODULE__)
	end

	def add_message(message) do
	Agent.get_and_update(__MODULE__, fn state ->
	id = state[:max_id] + 1
	message = Map.put(message, "id", id)
	messages = [message \| state[:messages]] \|> Enum.take(@max_messages)
	{message, %{max_id: id, messages: messages}}
	end)
	end

	def messages do
	Agent.get(__MODULE__, fn state -> state[:messages] \|> Enum.reverse() end)
	end
	end
	diff --git a/lib/pleroma/web/federator/retry_queue.ex b/lib/pleroma/web/federator/retry_queue.ex
	index 3db948c2e..9eab8c218 100644
	--- a/lib/pleroma/web/federator/retry_queue.ex
	+++ b/lib/pleroma/web/federator/retry_queue.ex
	@@ -1,239 +1,239 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Federator.RetryQueue do
	use GenServer

	require Logger

	def init(args) do
	queue_table = :ets.new(:pleroma_retry_queue, [:bag, :protected])

	{:ok, %{args \| queue_table: queue_table, running_jobs: :sets.new()}}
	end

	- def start_link do
	+ def start_link(_) do
	enabled =
	if Pleroma.Config.get(:env) == :test,
	do: true,
	else: Pleroma.Config.get([__MODULE__, :enabled], false)

	if enabled do
	Logger.info("Starting retry queue")

	linkres =
	GenServer.start_link(
	__MODULE__,
	%{delivered: 0, dropped: 0, queue_table: nil, running_jobs: nil},
	name: __MODULE__
	)

	maybe_kickoff_timer()
	linkres
	else
	Logger.info("Retry queue disabled")
	:ignore
	end
	end

	def enqueue(data, transport, retries \\ 0) do
	GenServer.cast(__MODULE__, {:maybe_enqueue, data, transport, retries + 1})
	end

	def get_stats do
	GenServer.call(__MODULE__, :get_stats)
	end

	def reset_stats do
	GenServer.call(__MODULE__, :reset_stats)
	end

	def get_retry_params(retries) do
	if retries > Pleroma.Config.get([__MODULE__, :max_retries]) do
	{:drop, "Max retries reached"}
	else
	{:retry, growth_function(retries)}
	end
	end

	def get_retry_timer_interval do
	Pleroma.Config.get([:retry_queue, :interval], 1000)
	end

	defp ets_count_expires(table, current_time) do
	:ets.select_count(
	table,
	[
	{
	{:"$1", :"$2"},
	[{:"=<", :"$1", {:const, current_time}}],
	[true]
	}
	]
	)
	end

	defp ets_pop_n_expired(table, current_time, desired) do
	{popped, _continuation} =
	:ets.select(
	table,
	[
	{
	{:"$1", :"$2"},
	[{:"=<", :"$1", {:const, current_time}}],
	[:"$_"]
	}
	],
	desired
	)

	popped
	\|> Enum.each(fn e ->
	:ets.delete_object(table, e)
	end)

	popped
	end

	def maybe_start_job(running_jobs, queue_table) do
	# we don't want to hit the ets or the DateTime more times than we have to
	# could optimize slightly further by not using the count, and instead grabbing
	# up to N objects early...
	current_time = DateTime.to_unix(DateTime.utc_now())
	n_running_jobs = :sets.size(running_jobs)

	if n_running_jobs < Pleroma.Config.get([__MODULE__, :max_jobs]) do
	n_ready_jobs = ets_count_expires(queue_table, current_time)

	if n_ready_jobs > 0 do
	# figure out how many we could start
	available_job_slots = Pleroma.Config.get([__MODULE__, :max_jobs]) - n_running_jobs
	start_n_jobs(running_jobs, queue_table, current_time, available_job_slots)
	else
	running_jobs
	end
	else
	running_jobs
	end
	end

	defp start_n_jobs(running_jobs, _queue_table, _current_time, 0) do
	running_jobs
	end

	defp start_n_jobs(running_jobs, queue_table, current_time, available_job_slots)
	when available_job_slots > 0 do
	candidates = ets_pop_n_expired(queue_table, current_time, available_job_slots)

	candidates
	\|> List.foldl(running_jobs, fn {_, e}, rj ->
	{:ok, pid} = Task.start(fn -> worker(e) end)
	mref = Process.monitor(pid)
	:sets.add_element(mref, rj)
	end)
	end

	def worker({:send, data, transport, retries}) do
	case transport.publish_one(data) do
	{:ok, _} ->
	GenServer.cast(__MODULE__, :inc_delivered)
	:delivered

	{:error, _reason} ->
	enqueue(data, transport, retries)
	:retry
	end
	end

	def handle_call(:get_stats, _from, %{delivered: delivery_count, dropped: drop_count} = state) do
	{:reply, %{delivered: delivery_count, dropped: drop_count}, state}
	end

	def handle_call(:reset_stats, _from, %{delivered: delivery_count, dropped: drop_count} = state) do
	{:reply, %{delivered: delivery_count, dropped: drop_count},
	%{state \| delivered: 0, dropped: 0}}
	end

	def handle_cast(:reset_stats, state) do
	{:noreply, %{state \| delivered: 0, dropped: 0}}
	end

	def handle_cast(
	{:maybe_enqueue, data, transport, retries},
	%{dropped: drop_count, queue_table: queue_table, running_jobs: running_jobs} = state
	) do
	case get_retry_params(retries) do
	{:retry, timeout} ->
	:ets.insert(queue_table, {timeout, {:send, data, transport, retries}})
	running_jobs = maybe_start_job(running_jobs, queue_table)
	{:noreply, %{state \| running_jobs: running_jobs}}

	{:drop, message} ->
	Logger.debug(message)
	{:noreply, %{state \| dropped: drop_count + 1}}
	end
	end

	def handle_cast(:kickoff_timer, state) do
	retry_interval = get_retry_timer_interval()
	Process.send_after(__MODULE__, :retry_timer_run, retry_interval)
	{:noreply, state}
	end

	def handle_cast(:inc_delivered, %{delivered: delivery_count} = state) do
	{:noreply, %{state \| delivered: delivery_count + 1}}
	end

	def handle_cast(:inc_dropped, %{dropped: drop_count} = state) do
	{:noreply, %{state \| dropped: drop_count + 1}}
	end

	def handle_info({:send, data, transport, retries}, %{delivered: delivery_count} = state) do
	case transport.publish_one(data) do
	{:ok, _} ->
	{:noreply, %{state \| delivered: delivery_count + 1}}

	{:error, _reason} ->
	enqueue(data, transport, retries)
	{:noreply, state}
	end
	end

	def handle_info(
	:retry_timer_run,
	%{queue_table: queue_table, running_jobs: running_jobs} = state
	) do
	maybe_kickoff_timer()
	running_jobs = maybe_start_job(running_jobs, queue_table)
	{:noreply, %{state \| running_jobs: running_jobs}}
	end

	def handle_info({:DOWN, ref, :process, _pid, _reason}, state) do
	%{running_jobs: running_jobs, queue_table: queue_table} = state
	running_jobs = :sets.del_element(ref, running_jobs)
	running_jobs = maybe_start_job(running_jobs, queue_table)
	{:noreply, %{state \| running_jobs: running_jobs}}
	end

	def handle_info(unknown, state) do
	Logger.debug("RetryQueue: don't know what to do with #{inspect(unknown)}, ignoring")
	{:noreply, state}
	end

	if Pleroma.Config.get(:env) == :test do
	defp growth_function(_retries) do
	_shutit = Pleroma.Config.get([__MODULE__, :initial_timeout])
	DateTime.to_unix(DateTime.utc_now()) - 1
	end
	else
	defp growth_function(retries) do
	round(Pleroma.Config.get([__MODULE__, :initial_timeout]) * :math.pow(retries, 3)) +
	DateTime.to_unix(DateTime.utc_now())
	end
	end

	defp maybe_kickoff_timer do
	GenServer.cast(__MODULE__, :kickoff_timer)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api.ex b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	index 46944dcbc..ac01d1ff3 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	@@ -1,89 +1,93 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.MastodonAPI do
	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Pagination
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	+ @spec follow(User.t(), User.t(), map) :: {:ok, User.t()} \| {:error, String.t()}
	def follow(follower, followed, params \\ %{}) do
	- options = cast_params(params)
	- reblogs = options[:reblogs]
	-
	result =
	if not User.following?(follower, followed) do
	CommonAPI.follow(follower, followed)
	else
	{:ok, follower, followed, nil}
	end

	- with {:ok, follower, followed, _} <- result do
	- reblogs
	- \|> case do
	- false -> CommonAPI.hide_reblogs(follower, followed)
	- _ -> CommonAPI.show_reblogs(follower, followed)
	- end
	- \|> case do
	+ with {:ok, follower, _followed, _} <- result do
	+ options = cast_params(params)
	+
	+ case reblogs_visibility(options[:reblogs], result) do
	{:ok, follower} -> {:ok, follower}
	_ -> {:ok, follower}
	end
	end
	end

	+ defp reblogs_visibility(false, {:ok, follower, followed, _}) do
	+ CommonAPI.hide_reblogs(follower, followed)
	+ end
	+
	+ defp reblogs_visibility(_, {:ok, follower, followed, _}) do
	+ CommonAPI.show_reblogs(follower, followed)
	+ end
	+
	+ @spec get_followers(User.t(), map()) :: list(User.t())
	def get_followers(user, params \\ %{}) do
	user
	\|> User.get_followers_query()
	\|> Pagination.fetch_paginated(params)
	end

	def get_friends(user, params \\ %{}) do
	user
	\|> User.get_friends_query()
	\|> Pagination.fetch_paginated(params)
	end

	def get_notifications(user, params \\ %{}) do
	options = cast_params(params)

	user
	\|> Notification.for_user_query(options)
	\|> restrict(:exclude_types, options)
	\|> Pagination.fetch_paginated(params)
	end

	def get_scheduled_activities(user, params \\ %{}) do
	user
	\|> ScheduledActivity.for_user_query()
	\|> Pagination.fetch_paginated(params)
	end

	defp cast_params(params) do
	param_types = %{
	exclude_types: {:array, :string},
	reblogs: :boolean,
	with_muted: :boolean
	}

	changeset = cast({%{}, param_types}, params, Map.keys(param_types))
	changeset.changes
	end

	defp restrict(query, :exclude_types, %{exclude_types: mastodon_types = [_ \| _]}) do
	ap_types =
	mastodon_types
	\|> Enum.map(&Activity.from_mastodon_notification_type/1)
	\|> Enum.filter(& &1)

	query
	\|> where([q, a], not fragment("? @> ARRAY[?->>'type']::varchar[]", ^ap_types, a.data))
	end

	defp restrict(query, _, _), do: query
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index 174e93468..7ce2b5b06 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,1871 +1,1861 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	alias Ecto.Changeset
	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Filter
	alias Pleroma.Formatter
	alias Pleroma.HTTP
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Pagination
	alias Pleroma.Plugs.RateLimiter
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.Stats
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.AppView
	alias Pleroma.Web.MastodonAPI.ConversationView
	alias Pleroma.Web.MastodonAPI.FilterView
	alias Pleroma.Web.MastodonAPI.ListView
	alias Pleroma.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.MastodonAPI.MastodonView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.ReportView
	alias Pleroma.Web.MastodonAPI.ScheduledActivityView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Scopes
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.TwitterAPI.TwitterAPI

	alias Pleroma.Web.ControllerHelper
	import Ecto.Query

	require Logger
	require Pleroma.Constants

	@rate_limited_relations_actions ~w(follow unfollow)a

	@rate_limited_status_actions ~w(reblog_status unreblog_status fav_status unfav_status
	post_status delete_status)a

	plug(
	RateLimiter,
	{:status_id_action, bucket_name: "status_id_action:reblog_unreblog", params: ["id"]}
	when action in ~w(reblog_status unreblog_status)a
	)

	plug(
	RateLimiter,
	{:status_id_action, bucket_name: "status_id_action:fav_unfav", params: ["id"]}
	when action in ~w(fav_status unfav_status)a
	)

	plug(
	RateLimiter,
	{:relations_id_action, params: ["id", "uri"]} when action in @rate_limited_relations_actions
	)

	plug(RateLimiter, :relations_actions when action in @rate_limited_relations_actions)
	plug(RateLimiter, :statuses_actions when action in @rate_limited_status_actions)
	plug(RateLimiter, :app_account_creation when action == :account_register)
	plug(RateLimiter, :search when action in [:search, :search2, :account_search])
	plug(RateLimiter, :password_reset when action == :password_reset)
	plug(RateLimiter, :account_confirmation_resend when action == :account_confirmation_resend)

	@local_mastodon_name "Mastodon-Local"

	action_fallback(:errors)

	def create_app(conn, params) do
	scopes = Scopes.fetch_scopes(params, ["read"])

	app_attrs =
	params
	\|> Map.drop(["scope", "scopes"])
	\|> Map.put("scopes", scopes)

	with cs <- App.register_changeset(%App{}, app_attrs),
	false <- cs.changes[:client_name] == @local_mastodon_name,
	{:ok, app} <- Repo.insert(cs) do
	conn
	\|> put_view(AppView)
	\|> render("show.json", %{app: app})
	end
	end

	defp add_if_present(
	map,
	params,
	params_field,
	map_field,
	value_function \\ fn x -> {:ok, x} end
	) do
	if Map.has_key?(params, params_field) do
	case value_function.(params[params_field]) do
	{:ok, new_value} -> Map.put(map, map_field, new_value)
	:error -> map
	end
	else
	map
	end
	end

	def update_credentials(%{assigns: %{user: user}} = conn, params) do
	original_user = user

	user_params =
	%{}
	\|> add_if_present(params, "display_name", :name)
	\|> add_if_present(params, "note", :bio, fn value -> {:ok, User.parse_bio(value, user)} end)
	\|> add_if_present(params, "avatar", :avatar, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :avatar) do
	{:ok, object.data}
	else
	_ -> :error
	end
	end)

	emojis_text = (user_params["display_name"] \|\| "") <> (user_params["note"] \|\| "")

	user_info_emojis =
	((user.info.emoji \|\| []) ++ Formatter.get_emoji_map(emojis_text))
	\|> Enum.dedup()

	info_params =
	[
	:no_rich_text,
	:locked,
	:hide_followers,
	:hide_follows,
	:hide_favorites,
	:show_role,
	:skip_thread_containment
	]
	\|> Enum.reduce(%{}, fn key, acc ->
	add_if_present(acc, params, to_string(key), key, fn value ->
	{:ok, ControllerHelper.truthy_param?(value)}
	end)
	end)
	\|> add_if_present(params, "default_scope", :default_scope)
	\|> add_if_present(params, "pleroma_settings_store", :pleroma_settings_store, fn value ->
	{:ok, Map.merge(user.info.pleroma_settings_store, value)}
	end)
	\|> add_if_present(params, "header", :banner, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :banner) do
	{:ok, object.data}
	else
	_ -> :error
	end
	end)
	\|> add_if_present(params, "pleroma_background_image", :background, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :background) do
	{:ok, object.data}
	else
	_ -> :error
	end
	end)
	\|> Map.put(:emoji, user_info_emojis)

	info_cng = User.Info.profile_update(user.info, info_params)

	with changeset <- User.update_changeset(user, user_params),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
	{:ok, user} <- User.update_and_set_cache(changeset) do
	if original_user != user do
	CommonAPI.update(user)
	end

	json(
	conn,
	AccountView.render("account.json", %{user: user, for: user, with_pleroma_settings: true})
	)
	else
	_e -> render_error(conn, :forbidden, "Invalid request")
	end
	end

	def update_avatar(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
	change = Changeset.change(user, %{avatar: nil})
	{:ok, user} = User.update_and_set_cache(change)
	CommonAPI.update(user)

	json(conn, %{url: nil})
	end

	def update_avatar(%{assigns: %{user: user}} = conn, params) do
	{:ok, object} = ActivityPub.upload(params, type: :avatar)
	change = Changeset.change(user, %{avatar: object.data})
	{:ok, user} = User.update_and_set_cache(change)
	CommonAPI.update(user)
	%{"url" => [%{"href" => href} \| _]} = object.data

	json(conn, %{url: href})
	end

	def update_banner(%{assigns: %{user: user}} = conn, %{"banner" => ""}) do
	with new_info <- %{"banner" => %{}},
	info_cng <- User.Info.profile_update(user.info, new_info),
	changeset <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, user} <- User.update_and_set_cache(changeset) do
	CommonAPI.update(user)

	json(conn, %{url: nil})
	end
	end

	def update_banner(%{assigns: %{user: user}} = conn, params) do
	with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}, type: :banner),
	new_info <- %{"banner" => object.data},
	info_cng <- User.Info.profile_update(user.info, new_info),
	changeset <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, user} <- User.update_and_set_cache(changeset) do
	CommonAPI.update(user)
	%{"url" => [%{"href" => href} \| _]} = object.data

	json(conn, %{url: href})
	end
	end

	def update_background(%{assigns: %{user: user}} = conn, %{"img" => ""}) do
	with new_info <- %{"background" => %{}},
	info_cng <- User.Info.profile_update(user.info, new_info),
	changeset <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	json(conn, %{url: nil})
	end
	end

	def update_background(%{assigns: %{user: user}} = conn, params) do
	with {:ok, object} <- ActivityPub.upload(params, type: :background),
	new_info <- %{"background" => object.data},
	info_cng <- User.Info.profile_update(user.info, new_info),
	changeset <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	%{"url" => [%{"href" => href} \| _]} = object.data

	json(conn, %{url: href})
	end
	end

	def verify_credentials(%{assigns: %{user: user}} = conn, _) do
	chat_token = Phoenix.Token.sign(conn, "user socket", user.id)

	account =
	AccountView.render("account.json", %{
	user: user,
	for: user,
	with_pleroma_settings: true,
	with_chat_token: chat_token
	})

	json(conn, account)
	end

	def verify_app_credentials(%{assigns: %{user: _user, token: token}} = conn, _) do
	with %Token{app: %App{} = app} <- Repo.preload(token, :app) do
	conn
	\|> put_view(AppView)
	\|> render("short.json", %{app: app})
	end
	end

	def user(%{assigns: %{user: for_user}} = conn, %{"id" => nickname_or_id}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id),
	true <- User.auth_active?(user) \|\| user.id == for_user.id \|\| User.superuser?(for_user) do
	account = AccountView.render("account.json", %{user: user, for: for_user})
	json(conn, account)
	else
	_e -> render_error(conn, :not_found, "Can't find user")
	end
	end

	@mastodon_api_level "2.7.2"

	def masto_instance(conn, _params) do
	instance = Config.get(:instance)

	response = %{
	uri: Web.base_url(),
	title: Keyword.get(instance, :name),
	description: Keyword.get(instance, :description),
	version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})",
	email: Keyword.get(instance, :email),
	urls: %{
	streaming_api: Pleroma.Web.Endpoint.websocket_url()
	},
	stats: Stats.get_stats(),
	thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
	languages: ["en"],
	registrations: Pleroma.Config.get([:instance, :registrations_open]),
	# Extra (not present in Mastodon):
	max_toot_chars: Keyword.get(instance, :limit),
	poll_limits: Keyword.get(instance, :poll_limits)
	}

	json(conn, response)
	end

	def peers(conn, _params) do
	json(conn, Stats.get_peers())
	end

	defp mastodonized_emoji do
	Pleroma.Emoji.get_all()
	\|> Enum.map(fn {shortcode, relative_url, tags} ->
	url = to_string(URI.merge(Web.base_url(), relative_url))

	%{
	"shortcode" => shortcode,
	"static_url" => url,
	"visible_in_picker" => true,
	"url" => url,
	"tags" => tags,
	# Assuming that a comma is authorized in the category name
	"category" => (tags -- ["Custom"]) \|> Enum.join(",")
	}
	end)
	end

	def custom_emojis(conn, _params) do
	mastodon_emoji = mastodonized_emoji()
	json(conn, mastodon_emoji)
	end

	defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
	params =
	conn.params
	\|> Map.drop(["since_id", "max_id", "min_id"])
	\|> Map.merge(params)

	last = List.last(activities)

	if last do
	max_id = last.id

	limit =
	params
	\|> Map.get("limit", "20")
	\|> String.to_integer()

	min_id =
	if length(activities) <= limit do
	activities
	\|> List.first()
	\|> Map.get(:id)
	else
	activities
	\|> Enum.at(limit * -1)
	\|> Map.get(:id)
	end

	{next_url, prev_url} =
	if param do
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{max_id: max_id})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{min_id: min_id})
	)
	}
	else
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{max_id: max_id})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{min_id: min_id})
	)
	}
	end

	conn
	\|> put_resp_header("link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")
	else
	conn
	end
	end

	def home_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("blocking_user", user)
	\|> Map.put("muting_user", user)
	\|> Map.put("user", user)

	activities =
	[user.ap_id \| user.following]
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

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

	def public_timeline(%{assigns: %{user: user}} = conn, params) do
	local_only = params["local"] in [true, "True", "true", "1"]

	activities =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("local_only", local_only)
	\|> Map.put("blocking_user", user)
	\|> Map.put("muting_user", user)
	+ \|> Map.put("user", user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:public_timeline, activities, false, %{"local" => local_only})
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(params["id"]) do
	params =
	params
	\|> Map.put("tag", params["tagged"])

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

	conn
	\|> add_link_headers(:user_statuses, activities, params["id"])
	\|> put_view(StatusView)
	\|> render("index.json", %{
	activities: activities,
	for: reading_user,
	as: :activity
	})
	end
	end

	def dm_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("blocking_user", user)
	\|> Map.put("user", user)
	\|> Map.put(:visibility, "direct")

	activities =
	[user.ap_id]
	\|> ActivityPub.fetch_activities_query(params)
	\|> Pagination.fetch_paginated(params)

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

	def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user})
	end
	end

	def get_context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	activities <-
	ActivityPub.fetch_activities_for_context(activity.data["context"], %{
	"blocking_user" => user,
	- "user" => user
	+ "user" => user,
	+ "exclude_id" => activity.id
	}),
	- activities <-
	- activities \|> Enum.filter(fn %{id: aid} -> to_string(aid) != to_string(id) end),
	- activities <-
	- activities \|> Enum.filter(fn %{data: %{"type" => type}} -> type == "Create" end),
	grouped_activities <- Enum.group_by(activities, fn %{id: id} -> id < activity.id end) do
	result = %{
	ancestors:
	StatusView.render(
	"index.json",
	for: user,
	activities: grouped_activities[true] \|\| [],
	as: :activity
	)
	\|> Enum.reverse(),
	# credo:disable-for-previous-line Credo.Check.Refactor.PipeChainStart
	descendants:
	StatusView.render(
	"index.json",
	for: user,
	activities: grouped_activities[false] \|\| [],
	as: :activity
	)
	\|> Enum.reverse()
	# credo:disable-for-previous-line Credo.Check.Refactor.PipeChainStart
	}

	json(conn, result)
	end
	end

	def get_poll(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Object{} = 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) do
	conn
	\|> put_view(StatusView)
	\|> try_render("poll.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 when is_nil(error) or error == false ->
	+ render_error(conn, :not_found, "Record not found")
	end
	end

	defp get_cached_vote_or_vote(user, object, choices) do
	idempotency_key = "polls:#{user.id}:#{object.data["id"]}"

	{_, res} =
	Cachex.fetch(:idempotency_cache, idempotency_key, fn _ ->
	case CommonAPI.vote(user, object, choices) do
	{:error, _message} = res -> {:ignore, res}
	res -> {:commit, res}
	end
	end)

	res
	end

	def poll_vote(%{assigns: %{user: user}} = conn, %{"id" => id, "choices" => choices}) do
	with %Object{} = object <- Object.get_by_id(id),
	true <- object.data["type"] == "Question",
	%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(user, object, choices) do
	conn
	\|> put_view(StatusView)
	\|> try_render("poll.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} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})
	end
	end

	def scheduled_statuses(%{assigns: %{user: user}} = conn, params) do
	with scheduled_activities <- MastodonAPI.get_scheduled_activities(user, params) do
	conn
	\|> add_link_headers(:scheduled_statuses, scheduled_activities)
	\|> put_view(ScheduledActivityView)
	\|> render("index.json", %{scheduled_activities: scheduled_activities})
	end
	end

	def show_scheduled_status(%{assigns: %{user: user}} = conn, %{"id" => scheduled_activity_id}) do
	with %ScheduledActivity{} = scheduled_activity <-
	ScheduledActivity.get(user, scheduled_activity_id) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", %{scheduled_activity: scheduled_activity})
	else
	_ -> {:error, :not_found}
	end
	end

	def update_scheduled_status(
	%{assigns: %{user: user}} = conn,
	%{"id" => scheduled_activity_id} = params
	) do
	with %ScheduledActivity{} = scheduled_activity <-
	ScheduledActivity.get(user, scheduled_activity_id),
	{:ok, scheduled_activity} <- ScheduledActivity.update(scheduled_activity, params) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", %{scheduled_activity: scheduled_activity})
	else
	nil -> {:error, :not_found}
	error -> error
	end
	end

	def delete_scheduled_status(%{assigns: %{user: user}} = conn, %{"id" => scheduled_activity_id}) do
	with %ScheduledActivity{} = scheduled_activity <-
	ScheduledActivity.get(user, scheduled_activity_id),
	{:ok, scheduled_activity} <- ScheduledActivity.delete(scheduled_activity) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", %{scheduled_activity: scheduled_activity})
	else
	nil -> {:error, :not_found}
	error -> error
	end
	end

	def post_status(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
	params =
	params
	\|> Map.put("in_reply_to_status_id", params["in_reply_to_id"])

	scheduled_at = params["scheduled_at"]

	if scheduled_at && ScheduledActivity.far_enough?(scheduled_at) do
	with {:ok, scheduled_activity} <-
	ScheduledActivity.create(user, %{"params" => params, "scheduled_at" => scheduled_at}) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", %{scheduled_activity: scheduled_activity})
	end
	else
	params = Map.drop(params, ["scheduled_at"])

	case CommonAPI.post(user, params) do
	{:error, message} ->
	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: message})

	{:ok, activity} ->
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end
	end

	def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	json(conn, %{})
	else
	_e -> render_error(conn, :forbidden, "Can't delete this post")
	end
	end

	def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user),
	%Activity{} = announce <- Activity.normalize(announce.data) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: announce, for: user, as: :activity})
	end
	end

	def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id_with_object(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def pin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def unpin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, _bookmark} <- Bookmark.create(user.id, activity.id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def unbookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, _bookmark} <- Bookmark.destroy(user.id, activity.id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def mute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	activity = Activity.get_by_id(id)

	with {:ok, activity} <- CommonAPI.add_mute(user, activity) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def unmute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	activity = Activity.get_by_id(id)

	with {:ok, activity} <- CommonAPI.remove_mute(user, activity) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def notifications(%{assigns: %{user: user}} = conn, params) do
	notifications = MastodonAPI.get_notifications(user, params)

	conn
	\|> add_link_headers(:notifications, notifications)
	\|> put_view(NotificationView)
	\|> render("index.json", %{notifications: notifications, for: user})
	end

	def get_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
	with {:ok, notification} <- Notification.get(user, id) do
	conn
	\|> put_view(NotificationView)
	\|> render("show.json", %{notification: notification, for: user})
	else
	{:error, reason} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{"error" => reason})
	end
	end

	def clear_notifications(%{assigns: %{user: user}} = conn, _params) do
	Notification.clear(user)
	json(conn, %{})
	end

	def dismiss_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
	with {:ok, _notif} <- Notification.dismiss(user, id) do
	json(conn, %{})
	else
	{:error, reason} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{"error" => reason})
	end
	end

	def destroy_multiple(%{assigns: %{user: user}} = conn, %{"ids" => ids} = _params) do
	Notification.destroy_multiple(user, ids)
	json(conn, %{})
	end

	def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	id = List.wrap(id)
	q = from(u in User, where: u.id in ^id)
	targets = Repo.all(q)

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

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

	def update_media(%{assigns: %{user: user}} = conn, data) do
	with %Object{} = object <- Repo.get(Object, data["id"]),
	true <- Object.authorize_mutation(object, user),
	true <- is_binary(data["description"]),
	description <- data["description"] do
	new_data = %{object.data \| "name" => description}

	{:ok, _} =
	object
	\|> Object.change(%{data: new_data})
	\|> Repo.update()

	attachment_data = Map.put(new_data, "id", object.id)

	conn
	\|> put_view(StatusView)
	\|> render("attachment.json", %{attachment: attachment_data})
	end
	end

	def upload(%{assigns: %{user: user}} = conn, %{"file" => file} = data) 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_view(StatusView)
	\|> render("attachment.json", %{attachment: attachment_data})
	end
	end

	def set_mascot(%{assigns: %{user: user}} = conn, %{"file" => file}) do
	with {:ok, object} <- ActivityPub.upload(file, actor: User.ap_id(user)),
	%{} = attachment_data <- Map.put(object.data, "id", object.id),
	%{type: type} = rendered <-
	StatusView.render("attachment.json", %{attachment: attachment_data}) do
	# Reject if not an image
	if type == "image" do
	# Sure!
	# Save to the user's info
	info_changeset = User.Info.mascot_update(user.info, rendered)

	user_changeset =
	user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, info_changeset)

	{:ok, _user} = User.update_and_set_cache(user_changeset)

	conn
	\|> json(rendered)
	else
	render_error(conn, :unsupported_media_type, "mascots can only be images")
	end
	end
	end

	def get_mascot(%{assigns: %{user: user}} = conn, _params) do
	mascot = User.get_mascot(user)

	conn
	\|> json(mascot)
	end

	def favourited_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	- with %Activity{data: %{"object" => object}} <- Activity.get_by_id(id),
	- %Object{data: %{"likes" => likes}} <- Object.normalize(object) do
	+ with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	+ %Object{data: %{"likes" => likes}} <- Object.normalize(activity) do
	q = from(u in User, where: u.ap_id in ^likes)

	users =
	Repo.all(q)
	\|> Enum.filter(&(not User.blocks?(user, &1)))

	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{for: user, users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

	def reblogged_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	- with %Activity{data: %{"object" => object}} <- Activity.get_by_id(id),
	- %Object{data: %{"announcements" => announces}} <- Object.normalize(object) do
	+ with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	+ %Object{data: %{"announcements" => announces}} <- Object.normalize(activity) do
	q = from(u in User, where: u.ap_id in ^announces)

	users =
	Repo.all(q)
	\|> Enum.filter(&(not User.blocks?(user, &1)))

	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{for: user, users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

	def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
	local_only = params["local"] in [true, "True", "true", "1"]

	tags =
	[params["tag"], params["any"]]
	\|> List.flatten()
	\|> Enum.uniq()
	\|> Enum.filter(& &1)
	\|> Enum.map(&String.downcase(&1))

	tag_all =
	params["all"] \|\|
	[]
	\|> Enum.map(&String.downcase(&1))

	tag_reject =
	params["none"] \|\|
	[]
	\|> Enum.map(&String.downcase(&1))

	activities =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("local_only", local_only)
	\|> Map.put("blocking_user", user)
	\|> Map.put("muting_user", user)
	+ \|> Map.put("user", user)
	\|> Map.put("tag", tags)
	\|> Map.put("tag_all", tag_all)
	\|> Map.put("tag_reject", tag_reject)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
	with %User{} = user <- User.get_cached_by_id(id),
	followers <- MastodonAPI.get_followers(user, params) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_followers -> []
	true -> followers
	end

	conn
	\|> add_link_headers(:followers, followers, user)
	\|> put_view(AccountView)
	\|> render("accounts.json", %{for: for_user, users: followers, as: :user})
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
	with %User{} = user <- User.get_cached_by_id(id),
	followers <- MastodonAPI.get_friends(user, params) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_follows -> []
	true -> followers
	end

	conn
	\|> add_link_headers(:following, followers, user)
	\|> put_view(AccountView)
	\|> render("accounts.json", %{for: for_user, users: followers, as: :user})
	end
	end

	def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
	with {:ok, follow_requests} <- User.get_follow_requests(followed) do
	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{for: followed, users: follow_requests, as: :user})
	end
	end

	def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
	with %User{} = follower <- User.get_cached_by_id(id),
	{:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: followed, target: follower})
	else
	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
	with %User{} = follower <- User.get_cached_by_id(id),
	{:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: followed, target: follower})
	else
	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with {_, %User{} = followed} <- {:followed, User.get_cached_by_id(id)},
	{_, true} <- {:followed, follower.id != followed.id},
	{:ok, follower} <- MastodonAPI.follow(follower, followed, conn.params) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	else
	{:followed, _} ->
	{:error, :not_found}

	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
	with {_, %User{} = followed} <- {:followed, User.get_cached_by_nickname(uri)},
	{_, true} <- {:followed, follower.id != followed.id},
	{:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("account.json", %{user: followed, for: follower})
	else
	{:followed, _} ->
	{:error, :not_found}

	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with {_, %User{} = followed} <- {:followed, User.get_cached_by_id(id)},
	{_, true} <- {:followed, follower.id != followed.id},
	{:ok, follower} <- CommonAPI.unfollow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	else
	{:followed, _} ->
	{:error, :not_found}

	error ->
	error
	end
	end

	def mute(%{assigns: %{user: muter}} = conn, %{"id" => id} = params) do
	notifications =
	if Map.has_key?(params, "notifications"),
	do: params["notifications"] in [true, "True", "true", "1"],
	else: true

	with %User{} = muted <- User.get_cached_by_id(id),
	{:ok, muter} <- User.mute(muter, muted, notifications) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: muter, target: muted})
	else
	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def unmute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
	with %User{} = muted <- User.get_cached_by_id(id),
	{:ok, muter} <- User.unmute(muter, muted) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: muter, target: muted})
	else
	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def mutes(%{assigns: %{user: user}} = conn, _) do
	with muted_accounts <- User.muted_users(user) do
	res = AccountView.render("accounts.json", users: muted_accounts, for: user, as: :user)
	json(conn, res)
	end
	end

	def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- User.get_cached_by_id(id),
	{:ok, blocker} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: blocker, target: blocked})
	else
	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- User.get_cached_by_id(id),
	{:ok, blocker} <- User.unblock(blocker, blocked),
	{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: blocker, target: blocked})
	else
	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def blocks(%{assigns: %{user: user}} = conn, _) do
	with blocked_accounts <- User.blocked_users(user) do
	res = AccountView.render("accounts.json", users: blocked_accounts, for: user, as: :user)
	json(conn, res)
	end
	end

	def domain_blocks(%{assigns: %{user: %{info: info}}} = conn, _) do
	json(conn, info.domain_blocks \|\| [])
	end

	def block_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
	User.block_domain(blocker, domain)
	json(conn, %{})
	end

	def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
	User.unblock_domain(blocker, domain)
	json(conn, %{})
	end

	def subscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %User{} = subscription_target <- User.get_cached_by_id(id),
	{:ok, subscription_target} = User.subscribe(user, subscription_target) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: user, target: subscription_target})
	else
	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def unsubscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %User{} = subscription_target <- User.get_cached_by_id(id),
	{:ok, subscription_target} = User.unsubscribe(user, subscription_target) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: user, target: subscription_target})
	else
	{:error, message} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: message})
	end
	end

	def favourites(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("favorited_by", user.ap_id)
	\|> Map.put("blocking_user", user)

	activities =
	ActivityPub.fetch_activities([], params)
	\|> Enum.reverse()

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

	def user_favourites(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
	with %User{} = user <- User.get_by_id(id),
	false <- user.info.hide_favorites do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("favorited_by", user.ap_id)
	\|> Map.put("blocking_user", for_user)

	recipients =
	if for_user do
	[Pleroma.Constants.as_public()] ++ [for_user.ap_id \| for_user.following]
	else
	[Pleroma.Constants.as_public()]
	end

	activities =
	recipients
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:favourites, activities)
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: for_user, as: :activity})
	else
	nil -> {:error, :not_found}
	true -> render_error(conn, :forbidden, "Can't get favorites")
	end
	end

	def bookmarks(%{assigns: %{user: user}} = conn, params) do
	user = User.get_cached_by_id(user.id)

	bookmarks =
	Bookmark.for_user_query(user.id)
	\|> Pagination.fetch_paginated(params)

	activities =
	bookmarks
	\|> Enum.map(fn b -> Map.put(b.activity, :bookmark, Map.delete(b, :activity)) end)

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

	def get_lists(%{assigns: %{user: user}} = conn, opts) do
	lists = Pleroma.List.for_user(user, opts)
	res = ListView.render("lists.json", lists: lists)
	json(conn, res)
	end

	def get_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	else
	_e -> render_error(conn, :not_found, "Record not found")
	end
	end

	def account_lists(%{assigns: %{user: user}} = conn, %{"id" => account_id}) do
	lists = Pleroma.List.get_lists_account_belongs(user, account_id)
	res = ListView.render("lists.json", lists: lists)
	json(conn, res)
	end

	def delete_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, _list} <- Pleroma.List.delete(list) do
	json(conn, %{})
	else
	_e ->
	json(conn, dgettext("errors", "error"))
	end
	end

	def create_list(%{assigns: %{user: user}} = conn, %{"title" => title}) do
	with {:ok, %Pleroma.List{} = list} <- Pleroma.List.create(title, user) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	end
	end

	def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
	accounts
	\|> Enum.each(fn account_id ->
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	%User{} = followed <- User.get_cached_by_id(account_id) do
	Pleroma.List.follow(list, followed)
	end
	end)

	json(conn, %{})
	end

	def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
	accounts
	\|> Enum.each(fn account_id ->
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	%User{} = followed <- User.get_cached_by_id(account_id) do
	Pleroma.List.unfollow(list, followed)
	end
	end)

	json(conn, %{})
	end

	def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, users} = Pleroma.List.get_following(list) do
	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{for: user, users: users, as: :user})
	end
	end

	def rename_list(%{assigns: %{user: user}} = conn, %{"id" => id, "title" => title}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, list} <- Pleroma.List.rename(list, title) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	else
	_e ->
	json(conn, dgettext("errors", "error"))
	end
	end

	def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
	with %Pleroma.List{title: _title, following: following} <- Pleroma.List.get(id, user) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("blocking_user", user)
	+ \|> Map.put("user", user)
	\|> Map.put("muting_user", user)

	# we must filter the following list for the user to avoid leaking statuses the user
	# does not actually have permission to see (for more info, peruse security issue #270).
	activities =
	following
	\|> Enum.filter(fn x -> x in user.following end)
	\|> ActivityPub.fetch_activities_bounded(following, params)
	\|> Enum.reverse()

	conn
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	else
	_e -> render_error(conn, :forbidden, "Error.")
	end
	end

	def index(%{assigns: %{user: user}} = conn, _params) do
	token = get_session(conn, :oauth_token)

	if user && token do
	mastodon_emoji = mastodonized_emoji()

	limit = Config.get([:instance, :limit])

	accounts =
	Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: user}))

	initial_state =
	%{
	meta: %{
	streaming_api_base_url: Pleroma.Web.Endpoint.websocket_url(),
	access_token: token,
	locale: "en",
	domain: Pleroma.Web.Endpoint.host(),
	admin: "1",
	me: "#{user.id}",
	unfollow_modal: false,
	boost_modal: false,
	delete_modal: true,
	auto_play_gif: false,
	display_sensitive_media: false,
	reduce_motion: false,
	max_toot_chars: limit,
	mascot: User.get_mascot(user)["url"]
	},
	poll_limits: Config.get([:instance, :poll_limits]),
	rights: %{
	delete_others_notice: present?(user.info.is_moderator),
	admin: present?(user.info.is_admin)
	},
	compose: %{
	me: "#{user.id}",
	default_privacy: user.info.default_scope,
	default_sensitive: false,
	allow_content_types: Config.get([:instance, :allowed_post_formats])
	},
	media_attachments: %{
	accept_content_types: [
	".jpg",
	".jpeg",
	".png",
	".gif",
	".webm",
	".mp4",
	".m4v",
	"image\/jpeg",
	"image\/png",
	"image\/gif",
	"video\/webm",
	"video\/mp4"
	]
	},
	settings:
	user.info.settings \|\|
	%{
	onboarded: true,
	home: %{
	shows: %{
	reblog: true,
	reply: true
	}
	},
	notifications: %{
	alerts: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	},
	shows: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	},
	sounds: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	}
	}
	},
	push_subscription: nil,
	accounts: accounts,
	custom_emojis: mastodon_emoji,
	char_limit: limit
	}
	\|> Jason.encode!()

	conn
	\|> put_layout(false)
	\|> put_view(MastodonView)
	\|> render("index.html", %{initial_state: initial_state})
	else
	conn
	\|> put_session(:return_to, conn.request_path)
	\|> redirect(to: "/web/login")
	end
	end

	def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
	info_cng = User.Info.mastodon_settings_update(user.info, settings)

	with changeset <- Ecto.Changeset.change(user),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	json(conn, %{})
	else
	e ->
	conn
	\|> put_status(:internal_server_error)
	\|> json(%{error: inspect(e)})
	end
	end

	def login(%{assigns: %{user: %User{}}} = conn, _params) do
	redirect(conn, to: local_mastodon_root_path(conn))
	end

	@doc "Local Mastodon FE login init action"
	def login(conn, %{"code" => auth_token}) do
	with {:ok, app} <- get_or_make_app(),
	%Authorization{} = auth <- Repo.get_by(Authorization, token: auth_token, app_id: app.id),
	{:ok, token} <- Token.exchange_token(app, auth) do
	conn
	\|> put_session(:oauth_token, token.token)
	\|> redirect(to: local_mastodon_root_path(conn))
	end
	end

	@doc "Local Mastodon FE callback action"
	def login(conn, _) do
	with {:ok, app} <- get_or_make_app() do
	path =
	o_auth_path(
	conn,
	:authorize,
	response_type: "code",
	client_id: app.client_id,
	redirect_uri: ".",
	scope: Enum.join(app.scopes, " ")
	)

	redirect(conn, to: path)
	end
	end

	defp local_mastodon_root_path(conn) do
	case get_session(conn, :return_to) do
	nil ->
	mastodon_api_path(conn, :index, ["getting-started"])

	return_to ->
	delete_session(conn, :return_to)
	return_to
	end
	end

	defp get_or_make_app do
	find_attrs = %{client_name: @local_mastodon_name, redirect_uris: "."}
	scopes = ["read", "write", "follow", "push"]

	with %App{} = app <- Repo.get_by(App, find_attrs) do
	{:ok, app} =
	if app.scopes == scopes do
	{:ok, app}
	else
	app
	\|> Ecto.Changeset.change(%{scopes: scopes})
	\|> Repo.update()
	end

	{:ok, app}
	else
	_e ->
	cs =
	App.register_changeset(
	%App{},
	Map.put(find_attrs, :scopes, scopes)
	)

	Repo.insert(cs)
	end
	end

	def logout(conn, _) do
	conn
	\|> clear_session
	\|> redirect(to: "/")
	end

	def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	Logger.debug("Unimplemented, returning unmodified relationship")

	with %User{} = target <- User.get_cached_by_id(id) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: user, target: target})
	end
	end

	def empty_array(conn, _) do
	Logger.debug("Unimplemented, returning an empty array")
	json(conn, [])
	end

	def empty_object(conn, _) do
	Logger.debug("Unimplemented, returning an empty object")
	json(conn, %{})
	end

	def get_filters(%{assigns: %{user: user}} = conn, _) do
	filters = Filter.get_filters(user)
	res = FilterView.render("filters.json", filters: filters)
	json(conn, res)
	end

	def create_filter(
	%{assigns: %{user: user}} = conn,
	%{"phrase" => phrase, "context" => context} = params
	) do
	query = %Filter{
	user_id: user.id,
	phrase: phrase,
	context: context,
	hide: Map.get(params, "irreversible", false),
	whole_word: Map.get(params, "boolean", true)
	# expires_at
	}

	{:ok, response} = Filter.create(query)
	res = FilterView.render("filter.json", filter: response)
	json(conn, res)
	end

	def get_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
	filter = Filter.get(filter_id, user)
	res = FilterView.render("filter.json", filter: filter)
	json(conn, res)
	end

	def update_filter(
	%{assigns: %{user: user}} = conn,
	%{"phrase" => phrase, "context" => context, "id" => filter_id} = params
	) do
	query = %Filter{
	user_id: user.id,
	filter_id: filter_id,
	phrase: phrase,
	context: context,
	hide: Map.get(params, "irreversible", nil),
	whole_word: Map.get(params, "boolean", true)
	# expires_at
	}

	{:ok, response} = Filter.update(query)
	res = FilterView.render("filter.json", filter: response)
	json(conn, res)
	end

	def delete_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
	query = %Filter{
	user_id: user.id,
	filter_id: filter_id
	}

	{:ok, _} = Filter.delete(query)
	json(conn, %{})
	end

	# fallback action
	#
	def errors(conn, {:error, %Changeset{} = changeset}) do
	error_message =
	changeset
	\|> Changeset.traverse_errors(fn {message, _opt} -> message end)
	\|> Enum.map_join(", ", fn {_k, v} -> v end)

	conn
	\|> put_status(:unprocessable_entity)
	\|> json(%{error: error_message})
	end

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

	def errors(conn, {:error, error_message}) do
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: error_message})
	end

	def errors(conn, _) do
	conn
	\|> put_status(:internal_server_error)
	\|> json(dgettext("errors", "Something went wrong"))
	end

	def suggestions(%{assigns: %{user: user}} = conn, _) do
	suggestions = Config.get(:suggestions)

	if Keyword.get(suggestions, :enabled, false) do
	api = Keyword.get(suggestions, :third_party_engine, "")
	timeout = Keyword.get(suggestions, :timeout, 5000)
	limit = Keyword.get(suggestions, :limit, 23)

	host = Config.get([Pleroma.Web.Endpoint, :url, :host])

	user = user.nickname

	url =
	api
	\|> String.replace("{{host}}", host)
	\|> String.replace("{{user}}", user)

	with {:ok, %{status: 200, body: body}} <-
	- HTTP.get(
	- url,
	- [],
	- adapter: [
	- recv_timeout: timeout,
	- pool: :default
	- ]
	- ),
	+ HTTP.get(url, [], adapter: [recv_timeout: timeout, pool: :default]),
	{:ok, data} <- Jason.decode(body) do
	data =
	data
	\|> Enum.slice(0, limit)
	\|> Enum.map(fn x ->
	- Map.put(
	- x,
	- "id",
	- case User.get_or_fetch(x["acct"]) do
	- {:ok, %User{id: id}} -> id
	- _ -> 0
	- end
	- )
	- end)
	- \|> Enum.map(fn x ->
	- Map.put(x, "avatar", MediaProxy.url(x["avatar"]))
	- end)
	- \|> Enum.map(fn x ->
	- Map.put(x, "avatar_static", MediaProxy.url(x["avatar_static"]))
	+ x
	+ \|> Map.put("id", fetch_suggestion_id(x))
	+ \|> Map.put("avatar", MediaProxy.url(x["avatar"]))
	+ \|> Map.put("avatar_static", MediaProxy.url(x["avatar_static"]))
	end)

	- conn
	- \|> json(data)
	+ json(conn, data)
	else
	- e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
	+ e ->
	+ Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
	end
	else
	json(conn, [])
	end
	end

	+ defp fetch_suggestion_id(attrs) do
	+ case User.get_or_fetch(attrs["acct"]) do
	+ {:ok, %User{id: id}} -> id
	+ _ -> 0
	+ end
	+ end
	+
	def status_card(%{assigns: %{user: user}} = conn, %{"id" => status_id}) do
	with %Activity{} = activity <- Activity.get_by_id(status_id),
	true <- Visibility.visible_for_user?(activity, user) do
	data =
	StatusView.render(
	"card.json",
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	)

	json(conn, data)
	else
	_e ->
	%{}
	end
	end

	def reports(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.report(user, params) do
	{:ok, activity} ->
	conn
	\|> put_view(ReportView)
	\|> try_render("report.json", %{activity: activity})

	{:error, err} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: err})
	end
	end

	def account_register(
	%{assigns: %{app: app}} = conn,
	%{"username" => nickname, "email" => _, "password" => _, "agreement" => true} = params
	) do
	params =
	params
	\|> Map.take([
	"email",
	"captcha_solution",
	"captcha_token",
	"captcha_answer_data",
	"token",
	"password"
	])
	\|> Map.put("nickname", nickname)
	\|> Map.put("fullname", params["fullname"] \|\| nickname)
	\|> Map.put("bio", params["bio"] \|\| "")
	\|> Map.put("confirm", params["password"])

	with {:ok, user} <- TwitterAPI.register_user(params, need_confirmation: true),
	{:ok, token} <- Token.create_token(app, user, %{scopes: app.scopes}) do
	json(conn, %{
	token_type: "Bearer",
	access_token: token.token,
	scope: app.scopes,
	created_at: Token.Utils.format_created_at(token)
	})
	else
	{:error, errors} ->
	conn
	\|> put_status(:bad_request)
	\|> json(errors)
	end
	end

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

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

	def conversations(%{assigns: %{user: user}} = conn, params) do
	participations = Participation.for_user_with_last_activity_id(user, params)

	conversations =
	Enum.map(participations, fn participation ->
	ConversationView.render("participation.json", %{participation: participation, user: user})
	end)

	conn
	\|> add_link_headers(:conversations, participations)
	\|> json(conversations)
	end

	def conversation_read(%{assigns: %{user: user}} = conn, %{"id" => participation_id}) do
	with %Participation{} = participation <-
	Repo.get_by(Participation, id: participation_id, user_id: user.id),
	{:ok, participation} <- Participation.mark_as_read(participation) do
	participation_view =
	ConversationView.render("participation.json", %{participation: participation, user: user})

	conn
	\|> json(participation_view)
	end
	end

	def password_reset(conn, params) do
	nickname_or_email = params["email"] \|\| params["nickname"]

	with {:ok, _} <- TwitterAPI.password_reset(nickname_or_email) do
	conn
	\|> put_status(:no_content)
	\|> json("")
	else
	{:error, "unknown user"} ->
	send_resp(conn, :not_found, "")

	{:error, _} ->
	send_resp(conn, :bad_request, "")
	end
	end

	def account_confirmation_resend(conn, params) do
	nickname_or_email = params["email"] \|\| params["nickname"]

	with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
	{:ok, _} <- User.try_send_confirmation_email(user) do
	conn
	\|> json_response(:no_content, "")
	end
	end

	def try_render(conn, target, params)
	when is_binary(target) do
	case render(conn, target, params) do
	nil -> render_error(conn, :not_implemented, "Can't display this activity")
	res -> res
	end
	end

	def try_render(conn, _, _) do
	render_error(conn, :not_implemented, "Can't display this activity")
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
	index 72c092f25..0ef568f0f 100644
	--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
	@@ -1,216 +1,216 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.HTML
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MediaProxy

	def render("accounts.json", %{users: users} = opts) do
	users
	\|> render_many(AccountView, "account.json", opts)
	\|> Enum.filter(&Enum.any?/1)
	end

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

	def render("mention.json", %{user: user}) do
	%{
	id: to_string(user.id),
	acct: user.nickname,
	username: username_from_nickname(user.nickname),
	url: User.profile_url(user)
	}
	end

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

	def render("relationship.json", %{user: %User{} = user, target: %User{} = target}) do
	- follow_activity = Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(user, target)
	+ follow_state = User.get_cached_follow_state(user, target)

	requested =
	- if follow_activity && !User.following?(target, user) do
	- follow_activity.data["state"] == "pending"
	+ if follow_state && !User.following?(user, target) do
	+ follow_state == "pending"
	else
	false
	end

	%{
	id: to_string(target.id),
	following: User.following?(user, target),
	followed_by: User.following?(target, user),
	blocking: User.blocks_ap_id?(user, target),
	blocked_by: User.blocks_ap_id?(target, user),
	muting: User.mutes?(user, target),
	muting_notifications: User.muted_notifications?(user, target),
	subscribing: User.subscribed_to?(user, target),
	requested: requested,
	domain_blocking: User.blocks_domain?(user, target),
	showing_reblogs: User.showing_reblogs?(user, target),
	endorsed: false
	}
	end

	def render("relationships.json", %{user: user, targets: targets}) do
	render_many(targets, AccountView, "relationship.json", user: user, as: :target)
	end

	defp do_render("account.json", %{user: user} = opts) do
	display_name = HTML.strip_tags(user.name \|\| user.nickname)

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

	following_count =
	((!user.info.hide_follows or opts[:for] == user) && user_info.following_count) \|\| 0

	followers_count =
	((!user.info.hide_followers or opts[:for] == user) && user_info.follower_count) \|\| 0

	bot = (user.info.source_data["type"] \|\| "Person") in ["Application", "Service"]

	emojis =
	(user.info.source_data["tag"] \|\| [])
	\|> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
	\|> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
	%{
	"shortcode" => String.trim(name, ":"),
	"url" => MediaProxy.url(url),
	"static_url" => MediaProxy.url(url),
	"visible_in_picker" => false
	}
	end)

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

	bio = HTML.filter_tags(user.bio, User.html_filter_policy(opts[:for]))

	relationship = render("relationship.json", %{user: opts[:for], target: user})

	%{
	id: to_string(user.id),
	username: username_from_nickname(user.nickname),
	acct: user.nickname,
	display_name: display_name,
	locked: user_info.locked,
	created_at: Utils.to_masto_date(user.inserted_at),
	followers_count: followers_count,
	following_count: following_count,
	statuses_count: user_info.note_count,
	note: bio \|\| "",
	url: User.profile_url(user),
	avatar: image,
	avatar_static: image,
	header: header,
	header_static: header,
	emojis: emojis,
	fields: fields,
	bot: bot,
	source: %{
	note: HTML.strip_tags((user.bio \|\| "") \|> String.replace("<br>", "\n")),
	sensitive: false,
	pleroma: %{}
	},

	# Pleroma extension
	pleroma: %{
	confirmation_pending: user_info.confirmation_pending,
	tags: user.tags,
	hide_followers: user.info.hide_followers,
	hide_follows: user.info.hide_follows,
	hide_favorites: user.info.hide_favorites,
	relationship: relationship,
	skip_thread_containment: user.info.skip_thread_containment,
	background_image: image_url(user.info.background) \|> MediaProxy.url()
	}
	}
	\|> maybe_put_role(user, opts[:for])
	\|> maybe_put_settings(user, opts[:for], user_info)
	\|> 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])
	end

	defp username_from_nickname(string) when is_binary(string) do
	hd(String.split(string, "@"))
	end

	defp username_from_nickname(_), do: nil

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

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

	defp maybe_put_settings_store(data, %User{info: info, id: id}, %User{id: id}, %{
	with_pleroma_settings: true
	}) do
	data
	\|> Kernel.put_in([:pleroma, :settings_store], info.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{info: %{show_role: true}} = user, _) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.info.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.info.is_moderator)
	end

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

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

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

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

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

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

	defp image_url(%{"url" => [%{"href" => href} \| _]}), do: href
	defp image_url(_), do: nil
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 02819e116..7e4e99280 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,495 +1,505 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	+ require Pleroma.Constants
	+
	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy

	import Pleroma.Web.ActivityPub.Visibility, only: [get_visibility: 1]

	# TODO: Add cached version.
	defp get_replied_to_activities([]), do: %{}

	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	- %{data: %{"type" => "Create", "object" => object}} ->
	- object = Object.normalize(object)
	- object.data["inReplyTo"] != "" && object.data["inReplyTo"]
	+ %{data: %{"type" => "Create"}} = activity ->
	+ object = Object.normalize(activity)
	+ object && object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	- \|> Activity.create_by_object_ap_id()
	+ \|> Activity.create_by_object_ap_id_with_object()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity)
	- Map.put(acc, object.data["id"], activity)
	+ if object, do: Map.put(acc, object.data["id"], activity), else: acc
	end)
	end

	defp get_user(ap_id) do
	cond do
	user = User.get_cached_by_ap_id(ap_id) ->
	user

	user = User.get_by_guessed_nickname(ap_id) ->
	user

	true ->
	User.error_user(ap_id)
	end
	end

	defp get_context_id(%{data: %{"context_id" => context_id}}) when not is_nil(context_id),
	do: context_id

	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
	do: Utils.context_to_conversation_id(context)

	defp get_context_id(_), do: nil

	defp reblogged?(activity, user) do
	object = Object.normalize(activity) \|\| %{}
	present?(user && user.ap_id in (object.data["announcements"] \|\| []))
	end

	def render("index.json", opts) do
	replied_to_activities = get_replied_to_activities(opts.activities)
	+ parallel = unless is_nil(opts[:parallel]), do: opts[:parallel], else: true

	opts.activities
	\|> safe_render_many(
	StatusView,
	"status.json",
	- Map.put(opts, :replied_to_activities, replied_to_activities)
	+ Map.put(opts, :replied_to_activities, replied_to_activities),
	+ parallel
	)
	end

	def render(
	"status.json",
	%{activity: %{data: %{"type" => "Announce", "object" => _object}} = activity} = opts
	) do
	user = get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])
	activity_object = Object.normalize(activity)

	reblogged_activity =
	Activity.create_by_object_ap_id(activity_object.data["id"])
	\|> Activity.with_preloaded_bookmark(opts[:for])
	+ \|> Activity.with_set_thread_muted_field(opts[:for])
	\|> Repo.one()

	reblogged = render("status.json", Map.put(opts, :activity, reblogged_activity))

	favorited = opts[:for] && opts[:for].ap_id in (activity_object.data["likes"] \|\| [])

	bookmarked = Activity.get_bookmark(reblogged_activity, opts[:for]) != nil

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	%{
	id: to_string(activity.id),
	uri: activity_object.data["id"],
	url: activity_object.data["id"],
	account: AccountView.render("account.json", %{user: user, for: opts[:for]}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: reblogged?(reblogged_activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmarked),
	muted: false,
	pinned: pinned?(activity, user),
	sensitive: false,
	spoiler_text: "",
	visibility: "public",
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [],
	pleroma: %{
	local: activity.local
	}
	}
	end

	def render("status.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	object = Object.normalize(activity)

	user = get_user(activity.data["actor"])
	+ user_follower_address = user.follower_address

	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0

	tags = object.data["tag"] \|\| []
	sensitive = object.data["sensitive"] \|\| Enum.member?(tags, "nsfw")

	tag_mentions =
	tags
	\|> Enum.filter(fn tag -> is_map(tag) and tag["type"] == "Mention" end)
	\|> Enum.map(fn tag -> tag["href"] end)

	mentions =
	(object.data["to"] ++ tag_mentions)
	\|> Enum.uniq()
	- \|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	+ \|> Enum.map(fn
	+ Pleroma.Constants.as_public() -> nil
	+ ^user_follower_address -> nil
	+ ap_id -> User.get_cached_by_ap_id(ap_id)
	+ end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	bookmarked = Activity.get_bookmark(activity, opts[:for]) != nil

	thread_muted? =
	case activity.thread_muted? do
	thread_muted? when is_boolean(thread_muted?) -> thread_muted?
	nil -> (opts[:for] && CommonAPI.thread_muted?(opts[:for], activity)) \|\| false
	end

	attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object.data["published"])

	reply_to = get_reply_to(activity, opts)

	reply_to_user = reply_to && get_user(reply_to.data["actor"])

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content"
	)

	content_plaintext =
	content
	\|> HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content"
	)

	summary = object.data["summary"] \|\| ""

	summary_html =
	summary
	\|> HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:summary"
	)

	summary_plaintext =
	summary
	\|> HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:summary"
	)

	card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	object.data["url"] \|\| object.data["external_url"] \|\| object.data["id"]
	end

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account: AccountView.render("account.json", %{user: user, for: opts[:for]}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	content: content_html,
	created_at: created_at,
	reblogs_count: announcement_count,
	replies_count: object.data["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: reblogged?(activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmarked),
	muted: thread_muted? \|\| User.mutes?(opts[:for], user),
	pinned: pinned?(activity, user),
	sensitive: sensitive,
	spoiler_text: summary_html,
	visibility: get_visibility(object),
	media_attachments: attachments,
	poll: render("poll.json", %{object: object, for: opts[:for]}),
	mentions: mentions,
	tags: build_tags(tags),
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: build_emojis(object.data["emoji"]),
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	in_reply_to_account_acct: reply_to_user && reply_to_user.nickname,
	content: %{"text/plain" => content_plaintext},
	spoiler_text: %{"text/plain" => summary_plaintext}
	}
	}
	end

	def render("status.json", _) do
	nil
	end

	def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
	page_url_data = URI.parse(page_url)

	page_url_data =
	if rich_media[:url] != nil do
	URI.merge(page_url_data, URI.parse(rich_media[:url]))
	else
	page_url_data
	end

	page_url = page_url_data \|> to_string

	image_url =
	if rich_media[:image] != nil do
	URI.merge(page_url_data, URI.parse(rich_media[:image]))
	\|> to_string
	else
	nil
	end

	site_name = rich_media[:site_name] \|\| page_url_data.host

	%{
	type: "link",
	provider_name: site_name,
	provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url \|> MediaProxy.url(),
	title: rich_media[:title] \|\| "",
	description: rich_media[:description] \|\| "",
	pleroma: %{
	opengraph: rich_media
	}
	}
	end

	def render("card.json", _) do
	nil
	end

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href = attachment_url["href"] \|> MediaProxy.url()

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)

	%{
	id: to_string(attachment["id"] \|\| hash_id),
	url: href,
	remote_url: href,
	preview_url: href,
	text_url: href,
	type: type,
	description: attachment["name"],
	pleroma: %{mime_type: media_type}
	}
	end

	def render("poll.json", %{object: object} = opts) do
	{multiple, options} =
	case object.data do
	%{"anyOf" => options} when is_list(options) -> {true, options}
	%{"oneOf" => options} when is_list(options) -> {false, options}
	_ -> {nil, nil}
	end

	if options do
	end_time =
	(object.data["closed"] \|\| object.data["endTime"])
	\|> NaiveDateTime.from_iso8601!()

	expired =
	end_time
	\|> NaiveDateTime.compare(NaiveDateTime.utc_now())
	\|> case do
	:lt -> true
	_ -> false
	end

	voted =
	if opts[:for] do
	existing_votes =
	Pleroma.Web.ActivityPub.Utils.get_existing_votes(opts[:for].ap_id, object)

	existing_votes != [] or opts[:for].ap_id == object.data["actor"]
	else
	false
	end

	{options, votes_count} =
	Enum.map_reduce(options, 0, fn %{"name" => name} = option, count ->
	current_count = option["replies"]["totalItems"] \|\| 0

	{%{
	title: HTML.strip_tags(name),
	votes_count: current_count
	}, current_count + count}
	end)

	%{
	# Mastodon uses separate ids for polls, but an object can't have
	# more than one poll embedded so object id is fine
	id: to_string(object.id),
	expires_at: Utils.to_masto_date(end_time),
	expired: expired,
	multiple: multiple,
	votes_count: votes_count,
	options: options,
	voted: voted,
	emojis: build_emojis(object.data["emoji"])
	}
	else
	nil
	end
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	object = Object.normalize(activity)

	with nil <- replied_to_activities[object.data["inReplyTo"]] do
	# If user didn't participate in the thread
	Activity.get_in_reply_to_activity(activity)
	end
	end

	def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
	object = Object.normalize(activity)

	if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
	Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
	else
	nil
	end
	end

	def render_content(%{data: %{"type" => "Video"}} = object) do
	with name when not is_nil(name) and name != "" <- object.data["name"] do
	"<p><a href=\"#{object.data["id"]}\">#{name}</a></p>#{object.data["content"]}"
	else
	_ -> object.data["content"] \|\| ""
	end
	end

	def render_content(%{data: %{"type" => object_type}} = object)
	when object_type in ["Article", "Page"] do
	with summary when not is_nil(summary) and summary != "" <- object.data["name"],
	url when is_bitstring(url) <- object.data["url"] do
	"<p><a href=\"#{url}\">#{summary}</a></p>#{object.data["content"]}"
	else
	_ -> object.data["content"] \|\| ""
	end
	end

	def render_content(object), do: object.data["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags = for tag when is_binary(tag) <- object_tags, do: tag

	Enum.reduce(object_tags, [], fn tag, tags ->
	tags ++ [%{name: tag, url: "/tag/#{tag}"}]
	end)
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

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

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pinned?(%Activity{id: id}, %User{info: %{pinned_activities: pinned_activities}}),
	do: id in pinned_activities
	end
	diff --git a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	index 54f89e65c..ee14cfd6b 100644
	--- a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	+++ b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	@@ -1,211 +1,165 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Nodeinfo.NodeinfoController do
	use Pleroma.Web, :controller

	alias Pleroma.Config
	alias Pleroma.Stats
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.Federator.Publisher

	def schemas(conn, _params) do
	response = %{
	links: [
	%{
	rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
	href: Web.base_url() <> "/nodeinfo/2.0.json"
	},
	%{
	rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
	href: Web.base_url() <> "/nodeinfo/2.1.json"
	}
	]
	}

	json(conn, response)
	end

	# returns a nodeinfo 2.0 map, since 2.1 just adds a repository field
	# under software.
	def raw_nodeinfo do
	stats = Stats.get_stats()

	- exclusions = Config.get([:instance, :mrf_transparency_exclusions])
	-
	- mrf_simple =
	- Config.get(:mrf_simple)
	- \|> Enum.map(fn {k, v} -> {k, Enum.reject(v, fn v -> v in exclusions end)} end)
	- \|> Enum.into(%{})
	-
	- # This horror is needed to convert regex sigils to strings
	- mrf_keyword =
	- Config.get(:mrf_keyword, [])
	- \|> Enum.map(fn {key, value} ->
	- {key,
	- Enum.map(value, fn
	- {pattern, replacement} ->
	- %{
	- "pattern" =>
	- if not is_binary(pattern) do
	- inspect(pattern)
	- else
	- pattern
	- end,
	- "replacement" => replacement
	- }
	-
	- pattern ->
	- if not is_binary(pattern) do
	- inspect(pattern)
	- else
	- pattern
	- end
	- end)}
	- end)
	- \|> Enum.into(%{})
	-
	- mrf_policies =
	- MRF.get_policies()
	- \|> Enum.map(fn policy -> to_string(policy) \|> String.split(".") \|> List.last() end)
	-
	quarantined = Config.get([:instance, :quarantined_instances], [])

	staff_accounts =
	User.all_superusers()
	\|> Enum.map(fn u -> u.ap_id end)

	- mrf_user_allowlist =
	- Config.get([:mrf_user_allowlist], [])
	- \|> Enum.into(%{}, fn {k, v} -> {k, length(v)} end)
	-
	federation_response =
	if Config.get([:instance, :mrf_transparency]) do
	- %{
	- mrf_policies: mrf_policies,
	- mrf_simple: mrf_simple,
	- mrf_keyword: mrf_keyword,
	- mrf_user_allowlist: mrf_user_allowlist,
	- quarantined_instances: quarantined,
	- exclusions: length(exclusions) > 0
	- }
	+ {:ok, data} = MRF.describe()
	+
	+ data
	+ \|> Map.merge(%{quarantined_instances: quarantined})
	else
	%{}
	end

	features =
	[
	"pleroma_api",
	"mastodon_api",
	"mastodon_api_streaming",
	"polls",
	"pleroma_explicit_addressing",
	if Config.get([:media_proxy, :enabled]) do
	"media_proxy"
	end,
	if Config.get([:gopher, :enabled]) do
	"gopher"
	end,
	if Config.get([:chat, :enabled]) do
	"chat"
	end,
	if Config.get([:suggestions, :enabled]) do
	"suggestions"
	end,
	if Config.get([:instance, :allow_relay]) do
	"relay"
	end,
	if Config.get([:instance, :safe_dm_mentions]) do
	"safe_dm_mentions"
	end
	]
	\|> Enum.filter(& &1)

	%{
	version: "2.0",
	software: %{
	name: Pleroma.Application.name() \|> String.downcase(),
	version: Pleroma.Application.version()
	},
	protocols: Publisher.gather_nodeinfo_protocol_names(),
	services: %{
	inbound: [],
	outbound: []
	},
	openRegistrations: Config.get([:instance, :registrations_open]),
	usage: %{
	users: %{
	total: stats.user_count \|\| 0
	},
	localPosts: stats.status_count \|\| 0
	},
	metadata: %{
	nodeName: Config.get([:instance, :name]),
	nodeDescription: Config.get([:instance, :description]),
	private: !Config.get([:instance, :public], true),
	suggestions: %{
	enabled: Config.get([:suggestions, :enabled], false),
	thirdPartyEngine: Config.get([:suggestions, :third_party_engine], ""),
	timeout: Config.get([:suggestions, :timeout], 5000),
	limit: Config.get([:suggestions, :limit], 23),
	web: Config.get([:suggestions, :web], "")
	},
	staffAccounts: staff_accounts,
	federation: federation_response,
	pollLimits: Config.get([:instance, :poll_limits]),
	postFormats: Config.get([:instance, :allowed_post_formats]),
	uploadLimits: %{
	general: Config.get([:instance, :upload_limit]),
	avatar: Config.get([:instance, :avatar_upload_limit]),
	banner: Config.get([:instance, :banner_upload_limit]),
	background: Config.get([:instance, :background_upload_limit])
	},
	accountActivationRequired: Config.get([:instance, :account_activation_required], false),
	invitesEnabled: Config.get([:instance, :invites_enabled], false),
	mailerEnabled: Config.get([Pleroma.Emails.Mailer, :enabled], false),
	features: features,
	restrictedNicknames: Config.get([Pleroma.User, :restricted_nicknames]),
	skipThreadContainment: Config.get([:instance, :skip_thread_containment], false)
	}
	}
	end

	# Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.0/schema.json
	# and https://github.com/jhass/nodeinfo/blob/master/schemas/2.1/schema.json
	def nodeinfo(conn, %{"version" => "2.0"}) do
	conn
	\|> put_resp_header(
	"content-type",
	"application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.0#; charset=utf-8"
	)
	\|> json(raw_nodeinfo())
	end

	def nodeinfo(conn, %{"version" => "2.1"}) do
	raw_response = raw_nodeinfo()

	updated_software =
	raw_response
	\|> Map.get(:software)
	\|> Map.put(:repository, Pleroma.Application.repository())

	response =
	raw_response
	\|> Map.put(:software, updated_software)
	\|> Map.put(:version, "2.1")

	conn
	\|> put_resp_header(
	"content-type",
	"application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.1#; charset=utf-8"
	)
	\|> json(response)
	end

	def nodeinfo(conn, _) do
	render_error(conn, :not_found, "Nodeinfo schema version not handled")
	end
	end
	diff --git a/lib/pleroma/web/oauth/token/clean_worker.ex b/lib/pleroma/web/oauth/token/clean_worker.ex
	index dca852449..f50098302 100644
	--- a/lib/pleroma/web/oauth/token/clean_worker.ex
	+++ b/lib/pleroma/web/oauth/token/clean_worker.ex
	@@ -1,41 +1,35 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.Token.CleanWorker do
	@moduledoc """
	The module represents functions to clean an expired oauth tokens.
	"""
	+ use GenServer
	+
	+ @ten_seconds 10_000
	+ @one_day 86_400_000

	- # 10 seconds
	- @start_interval 10_000
	@interval Pleroma.Config.get(
	- # 24 hours
	[:oauth2, :clean_expired_tokens_interval],
	- 86_400_000
	+ @one_day
	)
	- @queue :background

	alias Pleroma.Web.OAuth.Token

	- def start_link, do: GenServer.start_link(__MODULE__, nil)
	+ def start_link(_), do: GenServer.start_link(__MODULE__, %{})

	def init(_) do
	- if Pleroma.Config.get([:oauth2, :clean_expired_tokens], false) do
	- Process.send_after(self(), :perform, @start_interval)
	- {:ok, nil}
	- else
	- :ignore
	- end
	+ Process.send_after(self(), :perform, @ten_seconds)
	+ {:ok, nil}
	end

	@doc false
	def handle_info(:perform, state) do
	+ Token.delete_expired_tokens()
	+
	Process.send_after(self(), :perform, @interval)
	- PleromaJobQueue.enqueue(@queue, __MODULE__, [:clean])
	{:noreply, state}
	end
	-
	- # Job Worker Callbacks
	- def perform(:clean), do: Token.delete_expired_tokens()
	end
	diff --git a/lib/pleroma/web/streamer.ex b/lib/pleroma/web/streamer.ex
	index 9ee331030..bbaddd852 100644
	--- a/lib/pleroma/web/streamer.ex
	+++ b/lib/pleroma/web/streamer.ex
	@@ -1,325 +1,318 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Streamer do
	use GenServer
	require Logger
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.NotificationView

	@keepalive_interval :timer.seconds(30)

	- def start_link do
	+ def start_link(_) do
	GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
	end

	def add_socket(topic, socket) do
	GenServer.cast(__MODULE__, %{action: :add, socket: socket, topic: topic})
	end

	def remove_socket(topic, socket) do
	GenServer.cast(__MODULE__, %{action: :remove, socket: socket, topic: topic})
	end

	def stream(topic, item) do
	GenServer.cast(__MODULE__, %{action: :stream, topic: topic, item: item})
	end

	def init(args) do
	- spawn(fn ->
	- # 30 seconds
	- Process.sleep(@keepalive_interval)
	- GenServer.cast(__MODULE__, %{action: :ping})
	- end)
	+ Process.send_after(self(), %{action: :ping}, @keepalive_interval)

	{:ok, args}
	end

	- def handle_cast(%{action: :ping}, topics) do
	- Map.values(topics)
	+ def handle_info(%{action: :ping}, topics) do
	+ topics
	+ \|> Map.values()
	\|> List.flatten()
	\|> Enum.each(fn socket ->
	Logger.debug("Sending keepalive ping")
	send(socket.transport_pid, {:text, ""})
	end)

	- spawn(fn ->
	- # 30 seconds
	- Process.sleep(@keepalive_interval)
	- GenServer.cast(__MODULE__, %{action: :ping})
	- end)
	+ Process.send_after(self(), %{action: :ping}, @keepalive_interval)

	{:noreply, topics}
	end

	def handle_cast(%{action: :stream, topic: "direct", item: item}, topics) do
	recipient_topics =
	User.get_recipients_from_activity(item)
	\|> Enum.map(fn %{id: id} -> "direct:#{id}" end)

	Enum.each(recipient_topics \|\| [], fn user_topic ->
	Logger.debug("Trying to push direct message to #{user_topic}\n\n")
	push_to_socket(topics, user_topic, item)
	end)

	{:noreply, topics}
	end

	def handle_cast(%{action: :stream, topic: "participation", item: participation}, topics) do
	user_topic = "direct:#{participation.user_id}"
	Logger.debug("Trying to push a conversation participation to #{user_topic}\n\n")

	push_to_socket(topics, user_topic, participation)

	{:noreply, topics}
	end

	def handle_cast(%{action: :stream, topic: "list", item: item}, topics) do
	# filter the recipient list if the activity is not public, see #270.
	recipient_lists =
	case Visibility.is_public?(item) do
	true ->
	Pleroma.List.get_lists_from_activity(item)

	_ ->
	Pleroma.List.get_lists_from_activity(item)
	\|> Enum.filter(fn list ->
	owner = User.get_cached_by_id(list.user_id)

	Visibility.visible_for_user?(item, owner)
	end)
	end

	recipient_topics =
	recipient_lists
	\|> Enum.map(fn %{id: id} -> "list:#{id}" end)

	Enum.each(recipient_topics \|\| [], fn list_topic ->
	Logger.debug("Trying to push message to #{list_topic}\n\n")
	push_to_socket(topics, list_topic, item)
	end)

	{:noreply, topics}
	end

	def handle_cast(
	%{action: :stream, topic: topic, item: %Notification{} = item},
	topics
	)
	when topic in ["user", "user:notification"] do
	topics
	\|> Map.get("#{topic}:#{item.user_id}", [])
	\|> Enum.each(fn socket ->
	with %User{} = user <- User.get_cached_by_ap_id(socket.assigns[:user].ap_id),
	true <- should_send?(user, item),
	false <- CommonAPI.thread_muted?(user, item.activity) do
	send(
	socket.transport_pid,
	{:text, represent_notification(socket.assigns[:user], item)}
	)
	end
	end)

	{:noreply, topics}
	end

	def handle_cast(%{action: :stream, topic: "user", item: item}, topics) do
	Logger.debug("Trying to push to users")

	recipient_topics =
	User.get_recipients_from_activity(item)
	\|> Enum.map(fn %{id: id} -> "user:#{id}" end)

	Enum.each(recipient_topics, fn topic ->
	push_to_socket(topics, topic, item)
	end)

	{:noreply, topics}
	end

	def handle_cast(%{action: :stream, topic: topic, item: item}, topics) do
	Logger.debug("Trying to push to #{topic}")
	Logger.debug("Pushing item to #{topic}")
	push_to_socket(topics, topic, item)
	{:noreply, topics}
	end

	def handle_cast(%{action: :add, topic: topic, socket: socket}, sockets) do
	topic = internal_topic(topic, socket)
	sockets_for_topic = sockets[topic] \|\| []
	sockets_for_topic = Enum.uniq([socket \| sockets_for_topic])
	sockets = Map.put(sockets, topic, sockets_for_topic)
	Logger.debug("Got new conn for #{topic}")
	{:noreply, sockets}
	end

	def handle_cast(%{action: :remove, topic: topic, socket: socket}, sockets) do
	topic = internal_topic(topic, socket)
	sockets_for_topic = sockets[topic] \|\| []
	sockets_for_topic = List.delete(sockets_for_topic, socket)
	sockets = Map.put(sockets, topic, sockets_for_topic)
	Logger.debug("Removed conn for #{topic}")
	{:noreply, sockets}
	end

	def handle_cast(m, state) do
	Logger.info("Unknown: #{inspect(m)}, #{inspect(state)}")
	{:noreply, state}
	end

	defp represent_update(%Activity{} = activity, %User{} = user) do
	%{
	event: "update",
	payload:
	Pleroma.Web.MastodonAPI.StatusView.render(
	"status.json",
	activity: activity,
	for: user
	)
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end

	defp represent_update(%Activity{} = activity) do
	%{
	event: "update",
	payload:
	Pleroma.Web.MastodonAPI.StatusView.render(
	"status.json",
	activity: activity
	)
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end

	def represent_conversation(%Participation{} = participation) do
	%{
	event: "conversation",
	payload:
	Pleroma.Web.MastodonAPI.ConversationView.render("participation.json", %{
	participation: participation,
	user: participation.user
	})
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end

	@spec represent_notification(User.t(), Notification.t()) :: binary()
	defp represent_notification(%User{} = user, %Notification{} = notify) do
	%{
	event: "notification",
	payload:
	NotificationView.render(
	"show.json",
	%{notification: notify, for: user}
	)
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end

	defp should_send?(%User{} = user, %Activity{} = item) do
	blocks = user.info.blocks \|\| []
	mutes = user.info.mutes \|\| []
	reblog_mutes = user.info.muted_reblogs \|\| []
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.info.domain_blocks)

	with parent when not is_nil(parent) <- Object.normalize(item),
	true <- Enum.all?([blocks, mutes, reblog_mutes], &(item.actor not in &1)),
	true <- Enum.all?([blocks, mutes], &(parent.data["actor"] not in &1)),
	%{host: item_host} <- URI.parse(item.actor),
	%{host: parent_host} <- URI.parse(parent.data["actor"]),
	false <- Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, item_host),
	false <- Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, parent_host),
	true <- thread_containment(item, user) do
	true
	else
	_ -> false
	end
	end

	defp should_send?(%User{} = user, %Notification{activity: activity}) do
	should_send?(user, activity)
	end

	def push_to_socket(topics, topic, %Activity{data: %{"type" => "Announce"}} = item) do
	Enum.each(topics[topic] \|\| [], fn socket ->
	# Get the current user so we have up-to-date blocks etc.
	if socket.assigns[:user] do
	user = User.get_cached_by_ap_id(socket.assigns[:user].ap_id)

	if should_send?(user, item) do
	send(socket.transport_pid, {:text, represent_update(item, user)})
	end
	else
	send(socket.transport_pid, {:text, represent_update(item)})
	end
	end)
	end

	def push_to_socket(topics, topic, %Participation{} = participation) do
	Enum.each(topics[topic] \|\| [], fn socket ->
	send(socket.transport_pid, {:text, represent_conversation(participation)})
	end)
	end

	def push_to_socket(topics, topic, %Activity{
	data: %{"type" => "Delete", "deleted_activity_id" => deleted_activity_id}
	}) do
	Enum.each(topics[topic] \|\| [], fn socket ->
	send(
	socket.transport_pid,
	{:text, %{event: "delete", payload: to_string(deleted_activity_id)} \|> Jason.encode!()}
	)
	end)
	end

	def push_to_socket(_topics, _topic, %Activity{data: %{"type" => "Delete"}}), do: :noop

	def push_to_socket(topics, topic, item) do
	Enum.each(topics[topic] \|\| [], fn socket ->
	# Get the current user so we have up-to-date blocks etc.
	if socket.assigns[:user] do
	user = User.get_cached_by_ap_id(socket.assigns[:user].ap_id)
	blocks = user.info.blocks \|\| []
	mutes = user.info.mutes \|\| []

	with true <- Enum.all?([blocks, mutes], &(item.actor not in &1)),
	true <- thread_containment(item, user) do
	send(socket.transport_pid, {:text, represent_update(item, user)})
	end
	else
	send(socket.transport_pid, {:text, represent_update(item)})
	end
	end)
	end

	defp internal_topic(topic, socket) when topic in ~w[user user:notification direct] do
	"#{topic}:#{socket.assigns[:user].id}"
	end

	defp internal_topic(topic, _), do: topic

	@spec thread_containment(Activity.t(), User.t()) :: boolean()
	defp thread_containment(_activity, %User{info: %{skip_thread_containment: true}}), do: true

	defp thread_containment(activity, user) do
	if Config.get([:instance, :skip_thread_containment]) do
	true
	else
	ActivityPub.contain_activity(activity, user)
	end
	end
	end
	diff --git a/lib/pleroma/web/web.ex b/lib/pleroma/web/web.ex
	index b42f6887e..bfb6c7287 100644
	--- a/lib/pleroma/web/web.ex
	+++ b/lib/pleroma/web/web.ex
	@@ -1,109 +1,123 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web do
	@moduledoc """
	A module that keeps using definitions for controllers,
	views and so on.

	This can be used in your application as:

	use Pleroma.Web, :controller
	use Pleroma.Web, :view

	The definitions below will be executed for every view,
	controller, etc, so keep them short and clean, focused
	on imports, uses and aliases.

	Do NOT define functions inside the quoted expressions
	below.
	"""

	def controller do
	quote do
	use Phoenix.Controller, namespace: Pleroma.Web

	import Plug.Conn
	import Pleroma.Web.Gettext
	import Pleroma.Web.Router.Helpers
	import Pleroma.Web.TranslationHelpers

	plug(:set_put_layout)

	defp set_put_layout(conn, _) do
	put_layout(conn, Pleroma.Config.get(:app_layout, "app.html"))
	end
	end
	end

	def view do
	quote do
	use Phoenix.View,
	root: "lib/pleroma/web/templates",
	namespace: Pleroma.Web

	# Import convenience functions from controllers
	import Phoenix.Controller, only: [get_csrf_token: 0, get_flash: 2, view_module: 1]

	import Pleroma.Web.ErrorHelpers
	import Pleroma.Web.Gettext
	import Pleroma.Web.Router.Helpers

	require Logger

	@doc "Same as `render/3` but wrapped in a rescue block"
	def safe_render(view, template, assigns \\ %{}) do
	Phoenix.View.render(view, template, assigns)
	rescue
	error ->
	Logger.error(
	- "#{__MODULE__} failed to render #{inspect({view, template})}: #{inspect(error)}"
	+ "#{__MODULE__} failed to render #{inspect({view, template})}\n" <>
	+ Exception.format(:error, error, __STACKTRACE__)
	)

	- Logger.error(inspect(__STACKTRACE__))
	nil
	end

	@doc """
	- Same as `render_many/4` but wrapped in rescue block.
	+ Same as `render_many/4` but wrapped in rescue block and parallelized (unless disabled by passing false as a fifth argument).
	"""
	- def safe_render_many(collection, view, template, assigns \\ %{}) do
	+ def safe_render_many(collection, view, template, assigns \\ %{}, parallel \\ true)
	+
	+ def safe_render_many(collection, view, template, assigns, true) do
	+ Enum.map(collection, fn resource ->
	+ Task.async(fn ->
	+ as = Map.get(assigns, :as) \|\| view.__resource__
	+ assigns = Map.put(assigns, as, resource)
	+ safe_render(view, template, assigns)
	+ end)
	+ end)
	+ \|> Enum.map(&Task.await(&1, :infinity))
	+ \|> Enum.filter(& &1)
	+ end
	+
	+ def safe_render_many(collection, view, template, assigns, false) do
	Enum.map(collection, fn resource ->
	as = Map.get(assigns, :as) \|\| view.__resource__
	assigns = Map.put(assigns, as, resource)
	safe_render(view, template, assigns)
	end)
	\|> Enum.filter(& &1)
	end
	end
	end

	def router do
	quote do
	use Phoenix.Router
	# credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
	import Plug.Conn
	import Phoenix.Controller
	end
	end

	def channel do
	quote do
	# credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
	use Phoenix.Channel
	import Pleroma.Web.Gettext
	end
	end

	@doc """
	When used, dispatch to the appropriate controller/view/etc.
	"""
	defmacro __using__(which) when is_atom(which) do
	apply(__MODULE__, which, [])
	end

	def base_url do
	Pleroma.Web.Endpoint.url()
	end
	end
	diff --git a/mix.exs b/mix.exs
	index 334fabb33..3170d6f2d 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,267 +1,267 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("1.0.0"),
	elixir: "~> 1.7",
	elixirc_paths: elixirc_paths(Mix.env()),
	compilers: [:phoenix, :gettext] ++ Mix.compilers(),
	elixirc_options: [warnings_as_errors: true],
	xref: [exclude: [:eldap]],
	start_permanent: Mix.env() == :prod,
	aliases: aliases(),
	deps: deps(),
	test_coverage: [tool: ExCoveralls],
	preferred_cli_env: ["coveralls.html": :test],
	# Docs
	name: "Pleroma",
	homepage_url: "https://pleroma.social/",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	docs: [
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	logo: "priv/static/static/logo.png",
	extras: ["README.md", "CHANGELOG.md"] ++ Path.wildcard("docs/*/.md"),
	groups_for_extras: [
	"Installation manuals": Path.wildcard("docs/installation/*.md"),
	Configuration: Path.wildcard("docs/config/*.md"),
	Administration: Path.wildcard("docs/admin/*.md"),
	"Pleroma's APIs and Mastodon API extensions": Path.wildcard("docs/api/*.md")
	],
	main: "readme",
	output: "priv/static/doc"
	],
	releases: [
	pleroma: [
	include_executables_for: [:unix],
	applications: [ex_syslogger: :load, syslog: :load],
	steps: [:assemble, &copy_files/1, &copy_nginx_config/1]
	]
	]
	]
	end

	def copy_files(%{path: target_path} = release) do
	File.cp_r!("./rel/files", target_path)
	release
	end

	def copy_nginx_config(%{path: target_path} = release) do
	File.cp!(
	"./installation/pleroma.nginx",
	Path.join([target_path, "installation", "pleroma.nginx"])
	)

	release
	end

	# Configuration for the OTP application.
	#
	# Type `mix help compile.app` for more information.
	def application do
	[
	mod: {Pleroma.Application, []},
	extra_applications: [:logger, :runtime_tools, :comeonin, :quack],
	included_applications: [:ex_syslogger]
	]
	end

	# Specifies which paths to compile per environment.
	defp elixirc_paths(:test), do: ["lib", "test/support"]
	defp elixirc_paths(_), do: ["lib"]

	# Specifies OAuth dependencies.
	defp oauth_deps do
	oauth_strategy_packages =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(fn strategy_entry ->
	with [_strategy, dependency] <- String.split(strategy_entry, ":") do
	dependency
	else
	[strategy] -> "ueberauth_#{strategy}"
	end
	end)

	for s <- oauth_strategy_packages, do: {String.to_atom(s), ">= 0.0.0"}
	end

	# Specifies your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	[
	{:phoenix, "~> 1.4.8"},
	- {:tzdata, "~> 1.0"},
	+ {:tzdata, "~> 0.5.21"},
	{:plug_cowboy, "~> 2.0"},
	{:phoenix_pubsub, "~> 1.1"},
	{:phoenix_ecto, "~> 4.0"},
	{:ecto_sql, "~> 3.1"},
	{:postgrex, ">= 0.13.5"},
	{:gettext, "~> 0.15"},
	{:comeonin, "~> 4.1.1"},
	{:pbkdf2_elixir, "~> 0.12.3"},
	{:trailing_format_plug, "~> 0.0.7"},
	{:html_sanitize_ex, "~> 1.3.0"},
	{:html_entities, "~> 0.4"},
	{:phoenix_html, "~> 2.10"},
	{:calendar, "~> 0.17.4"},
	{:cachex, "~> 3.0.2"},
	{:poison, "~> 3.0", override: true},
	{:tesla, "~> 1.2"},
	{:jason, "~> 1.0"},
	{:mogrify, "~> 0.6.1"},
	{:ex_aws, "~> 2.1"},
	{:ex_aws_s3, "~> 2.0"},
	{:sweet_xml, "~> 0.6.6"},
	{:earmark, "~> 1.3"},
	{:bbcode, "~> 0.1.1"},
	{:ex_machina, "~> 2.3", only: :test},
	{:credo, "~> 0.9.3", only: [:dev, :test]},
	{:mock, "~> 0.3.3", only: :test},
	{:crypt,
	git: "https://github.com/msantos/crypt", ref: "1f2b58927ab57e72910191a7ebaeff984382a1d3"},
	{:cors_plug, "~> 1.5"},
	{:ex_doc, "~> 0.20.2", only: :dev, runtime: false},
	{:web_push_encryption, "~> 0.2.1"},
	{:swoosh, "~> 0.23.2"},
	{:phoenix_swoosh, "~> 0.2"},
	{:gen_smtp, "~> 0.13"},
	{:websocket_client, git: "https://github.com/jeremyong/websocket_client.git", only: :test},
	{:floki, "~> 0.20.0"},
	{:ex_syslogger, github: "slashmili/ex_syslogger", tag: "1.4.0"},
	{:timex, "~> 3.5"},
	{:ueberauth, "~> 0.4"},
	{:auto_linker,
	git: "https://git.pleroma.social/pleroma/auto_linker.git",
	ref: "95e8188490e97505c56636c1379ffdf036c1fdde"},
	{:http_signatures,
	git: "https://git.pleroma.social/pleroma/http_signatures.git",
	ref: "293d77bb6f4a67ac8bde1428735c3b42f22cbb30"},
	{:pleroma_job_queue, "~> 0.3"},
	{:telemetry, "~> 0.3"},
	{:prometheus_ex, "~> 3.0"},
	{:prometheus_plugs, "~> 1.1"},
	{:prometheus_phoenix, "~> 1.3"},
	{:prometheus_ecto, "~> 1.4"},
	{:recon, github: "ferd/recon", tag: "2.4.0"},
	{:quack, "~> 0.1.1"},
	{:joken, "~> 2.0"},
	{:benchee, "~> 1.0"},
	{:esshd, "~> 0.1.0", runtime: Application.get_env(:esshd, :enabled, false)},
	{:ex_rated, "~> 1.3"},
	{:ex_const, "~> 0.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:excoveralls, "~> 0.11.1", only: :test},
	{:mox, "~> 0.5", only: :test}
	] ++ oauth_deps()
	end

	# Aliases are shortcuts or tasks specific to the current project.
	# For example, to create, migrate and run the seeds file at once:
	#
	# $ mix ecto.setup
	#
	# See the documentation for `Mix` for more info on aliases.
	defp aliases do
	[
	"ecto.migrate": ["pleroma.ecto.migrate"],
	"ecto.rollback": ["pleroma.ecto.rollback"],
	"ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
	"ecto.reset": ["ecto.drop", "ecto.setup"],
	test: ["ecto.create --quiet", "ecto.migrate", "test"]
	]
	end

	# Builds a version string made of:
	# * the application version
	# * a pre-release if ahead of the tag: the describe string (-count-commithash)
	# * branch name
	# * build metadata:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	identifier_filter = ~r/[^0-9a-z\-]+/i

	# Pre-release version, denoted from patch version with a hyphen
	{git_tag, git_pre_release} =
	with {tag, 0} <-
	System.cmd("git", ["describe", "--tags", "--abbrev=0"], stderr_to_stdout: true),
	tag = String.trim(tag),
	{describe, 0} <- System.cmd("git", ["describe", "--tags", "--abbrev=8"]),
	describe = String.trim(describe),
	ahead <- String.replace(describe, tag, ""),
	ahead <- String.trim_leading(ahead, "-") do
	{String.replace_prefix(tag, "v", ""), if(ahead != "", do: String.trim(ahead))}
	else
	_ ->
	{commit_hash, 0} = System.cmd("git", ["rev-parse", "--short", "HEAD"])
	{nil, "0-g" <> String.trim(commit_hash)}
	end

	if git_tag && version != git_tag do
	Mix.shell().error(
	"Application version #{inspect(version)} does not match git tag #{inspect(git_tag)}"
	)
	end

	# Branch name as pre-release version component, denoted with a dot
	branch_name =
	with {branch_name, 0} <- System.cmd("git", ["rev-parse", "--abbrev-ref", "HEAD"]),
	branch_name <- String.trim(branch_name),
	branch_name <- System.get_env("PLEROMA_BUILD_BRANCH") \|\| branch_name,
	true <- branch_name not in ["master", "HEAD"] do
	branch_name =
	branch_name
	\|> String.trim()
	\|> String.replace(identifier_filter, "-")

	branch_name
	end

	build_name =
	cond do
	name = Application.get_env(:pleroma, :build_name) -> name
	name = System.get_env("PLEROMA_BUILD_NAME") -> name
	true -> nil
	end

	env_name = if Mix.env() != :prod, do: to_string(Mix.env())
	env_override = System.get_env("PLEROMA_BUILD_ENV")

	env_name =
	case env_override do
	nil -> env_name
	env_override when env_override in ["", "prod"] -> nil
	env_override -> env_override
	end

	# Pre-release version, denoted by appending a hyphen
	# and a series of dot separated identifiers
	pre_release =
	[git_pre_release, branch_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "-" <> String.replace(string, identifier_filter, "-")
	end).()

	# Build metadata, denoted with a plus sign
	build_metadata =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join(".")
	\|> (fn
	"" -> nil
	string -> "+" <> String.replace(string, identifier_filter, "-")
	end).()

	[version, pre_release, build_metadata]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end
	end
	diff --git a/mix.lock b/mix.lock
	index f8ee80c83..2639e96e9 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,96 +1,96 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm"},
	"auto_linker": {:git, "https://git.pleroma.social/pleroma/auto_linker.git", "95e8188490e97505c56636c1379ffdf036c1fdde", [ref: "95e8188490e97505c56636c1379ffdf036c1fdde"]},
	"base64url": {:hex, :base64url, "0.0.1", "36a90125f5948e3afd7be97662a1504b934dd5dac78451ca6e9abf85a10286be", [:rebar], [], "hexpm"},
	"bbcode": {:hex, :bbcode, "0.1.1", "0023e2c7814119b2e620b7add67182e3f6019f92bfec9a22da7e99821aceba70", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
	"benchee": {:hex, :benchee, "1.0.1", "66b211f9bfd84bd97e6d1beaddf8fc2312aaabe192f776e8931cb0c16f53a521", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}], "hexpm"},
	"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm"},
	"cachex": {:hex, :cachex, "3.0.3", "4e2d3e05814a5738f5ff3903151d5c25636d72a3527251b753f501ad9c657967", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm"},
	"calendar": {:hex, :calendar, "0.17.6", "ec291cb2e4ba499c2e8c0ef5f4ace974e2f9d02ae9e807e711a9b0c7850b9aee", [:mix], [{:tzdata, "~> 0.5.20 or ~> 0.1.201603 or ~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm"},
	"certifi": {:hex, :certifi, "2.5.1", "867ce347f7c7d78563450a18a6a28a8090331e77fa02380b4a21962a65d36ee5", [:rebar3], [{:parse_trans, "~>3.3", [hex: :parse_trans, repo: "hexpm", optional: false]}], "hexpm"},
	"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm"},
	"comeonin": {:hex, :comeonin, "4.1.2", "3eb5620fd8e35508991664b4c2b04dd41e52f1620b36957be837c1d7784b7592", [:mix], [{:argon2_elixir, "~> 1.2", [hex: :argon2_elixir, repo: "hexpm", optional: true]}, {:bcrypt_elixir, "~> 0.12.1 or ~> 1.0", [hex: :bcrypt_elixir, repo: "hexpm", optional: true]}, {:pbkdf2_elixir, "~> 0.12", [hex: :pbkdf2_elixir, repo: "hexpm", optional: true]}], "hexpm"},
	"connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"},
	"cors_plug": {:hex, :cors_plug, "1.5.2", "72df63c87e4f94112f458ce9d25800900cc88608c1078f0e4faddf20933eda6e", [:mix], [{:plug, "~> 1.3 or ~> 1.4 or ~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"cowboy": {:hex, :cowboy, "2.6.3", "99aa50e94e685557cad82e704457336a453d4abcb77839ad22dbe71f311fcc06", [:rebar3], [{:cowlib, "~> 2.7.3", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.7.1", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm"},
	"cowlib": {:hex, :cowlib, "2.7.3", "a7ffcd0917e6d50b4d5fb28e9e2085a0ceb3c97dea310505f7460ff5ed764ce9", [:rebar3], [], "hexpm"},
	"credo": {:hex, :credo, "0.9.3", "76fa3e9e497ab282e0cf64b98a624aa11da702854c52c82db1bf24e54ab7c97a", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:poison, ">= 0.0.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"},
	"crontab": {:hex, :crontab, "1.1.7", "b9219f0bdc8678b94143655a8f229716c5810c0636a4489f98c0956137e53985", [:mix], [{:ecto, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	"crypt": {:git, "https://github.com/msantos/crypt", "1f2b58927ab57e72910191a7ebaeff984382a1d3", [ref: "1f2b58927ab57e72910191a7ebaeff984382a1d3"]},
	"db_connection": {:hex, :db_connection, "2.0.6", "bde2f85d047969c5b5800cb8f4b3ed6316c8cb11487afedac4aa5f93fd39abfa", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"},
	"decimal": {:hex, :decimal, "1.8.0", "ca462e0d885f09a1c5a342dbd7c1dcf27ea63548c65a65e67334f4b61803822e", [:mix], [], "hexpm"},
	"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm"},
	"earmark": {:hex, :earmark, "1.3.2", "b840562ea3d67795ffbb5bd88940b1bed0ed9fa32834915125ea7d02e35888a5", [:mix], [], "hexpm"},
	"ecto": {:hex, :ecto, "3.1.4", "69d852da7a9f04ede725855a35ede48d158ca11a404fe94f8b2fb3b2162cd3c9", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
	"ecto_sql": {:hex, :ecto_sql, "3.1.3", "2c536139190492d9de33c5fefac7323c5eaaa82e1b9bf93482a14649042f7cd9", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.1.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:myxql, "~> 0.2.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
	"esshd": {:hex, :esshd, "0.1.0", "6f93a2062adb43637edad0ea7357db2702a4b80dd9683482fe00f5134e97f4c1", [:mix], [], "hexpm"},
	"eternal": {:hex, :eternal, "1.2.0", "e2a6b6ce3b8c248f7dc31451aefca57e3bdf0e48d73ae5043229380a67614c41", [:mix], [], "hexpm"},
	"ex2ms": {:hex, :ex2ms, "1.5.0", "19e27f9212be9a96093fed8cdfbef0a2b56c21237196d26760f11dfcfae58e97", [:mix], [], "hexpm"},
	"ex_aws": {:hex, :ex_aws, "2.1.0", "b92651527d6c09c479f9013caa9c7331f19cba38a650590d82ebf2c6c16a1d8a", [:mix], [{:configparser_ex, "~> 2.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "1.6.3 or 1.6.5 or 1.7.1 or 1.8.6 or ~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jsx, "~> 2.8", [hex: :jsx, repo: "hexpm", optional: true]}, {:poison, ">= 1.2.0", [hex: :poison, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}, {:xml_builder, "~> 0.1.0", [hex: :xml_builder, repo: "hexpm", optional: true]}], "hexpm"},
	"ex_aws_s3": {:hex, :ex_aws_s3, "2.0.1", "9e09366e77f25d3d88c5393824e613344631be8db0d1839faca49686e99b6704", [: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"},
	"ex_const": {:hex, :ex_const, "0.2.4", "d06e540c9d834865b012a17407761455efa71d0ce91e5831e86881b9c9d82448", [:mix], [], "hexpm"},
	"ex_doc": {:hex, :ex_doc, "0.20.2", "1bd0dfb0304bade58beb77f20f21ee3558cc3c753743ae0ddbb0fd7ba2912331", [:mix], [{:earmark, "~> 1.3", [hex: :earmark, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.10", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm"},
	"ex_machina": {:hex, :ex_machina, "2.3.0", "92a5ad0a8b10ea6314b876a99c8c9e3f25f4dde71a2a835845b136b9adaf199a", [: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"},
	"ex_rated": {:hex, :ex_rated, "1.3.3", "30ecbdabe91f7eaa9d37fa4e81c85ba420f371babeb9d1910adbcd79ec798d27", [:mix], [{:ex2ms, "~> 1.5", [hex: :ex2ms, repo: "hexpm", optional: false]}], "hexpm"},
	"ex_syslogger": {:git, "https://github.com/slashmili/ex_syslogger.git", "f3963399047af17e038897c69e20d552e6899e1d", [tag: "1.4.0"]},
	"excoveralls": {:hex, :excoveralls, "0.11.1", "dd677fbdd49114fdbdbf445540ec735808250d56b011077798316505064edb2c", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm"},
	"floki": {:hex, :floki, "0.20.4", "be42ac911fece24b4c72f3b5846774b6e61b83fe685c2fc9d62093277fb3bc86", [:mix], [{:html_entities, "~> 0.4.0", [hex: :html_entities, repo: "hexpm", optional: false]}, {:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
	"gen_smtp": {:hex, :gen_smtp, "0.14.0", "39846a03522456077c6429b4badfd1d55e5e7d0fdfb65e935b7c5e38549d9202", [:rebar3], [], "hexpm"},
	"gettext": {:hex, :gettext, "0.17.0", "abe21542c831887a2b16f4c94556db9c421ab301aee417b7c4fbde7fbdbe01ec", [:mix], [], "hexpm"},
	"hackney": {:hex, :hackney, "1.15.1", "9f8f471c844b8ce395f7b6d8398139e26ddca9ebc171a8b91342ee15a19963f4", [:rebar3], [{:certifi, "2.5.1", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "6.0.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "1.0.1", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "1.1.4", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm"},
	"html_entities": {:hex, :html_entities, "0.4.0", "f2fee876858cf6aaa9db608820a3209e45a087c5177332799592142b50e89a6b", [:mix], [], "hexpm"},
	"html_sanitize_ex": {:hex, :html_sanitize_ex, "1.3.0", "f005ad692b717691203f940c686208aa3d8ffd9dd4bb3699240096a51fa9564e", [:mix], [{:mochiweb, "~> 2.15", [hex: :mochiweb, repo: "hexpm", optional: false]}], "hexpm"},
	"http_signatures": {:git, "https://git.pleroma.social/pleroma/http_signatures.git", "293d77bb6f4a67ac8bde1428735c3b42f22cbb30", [ref: "293d77bb6f4a67ac8bde1428735c3b42f22cbb30"]},
	"httpoison": {:hex, :httpoison, "1.2.0", "2702ed3da5fd7a8130fc34b11965c8cfa21ade2f232c00b42d96d4967c39a3a3", [:mix], [{:hackney, "~> 1.8", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
	"idna": {:hex, :idna, "6.0.0", "689c46cbcdf3524c44d5f3dde8001f364cd7608a99556d8fbd8239a5798d4c10", [:rebar3], [{:unicode_util_compat, "0.4.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm"},
	"jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
	"joken": {:hex, :joken, "2.0.1", "ec9ab31bf660f343380da033b3316855197c8d4c6ef597fa3fcb451b326beb14", [:mix], [{:jose, "~> 1.9", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm"},
	"jose": {:hex, :jose, "1.9.0", "4167c5f6d06ffaebffd15cdb8da61a108445ef5e85ab8f5a7ad926fdf3ada154", [:mix, :rebar3], [{:base64url, "~> 0.0.1", [hex: :base64url, repo: "hexpm", optional: false]}], "hexpm"},
	"makeup": {:hex, :makeup, "0.8.0", "9cf32aea71c7fe0a4b2e9246c2c4978f9070257e5c9ce6d4a28ec450a839b55f", [:mix], [{:nimble_parsec, "~> 0.5.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.13.0", "be7a477997dcac2e48a9d695ec730b2d22418292675c75aa2d34ba0909dcdeda", [:mix], [{:makeup, "~> 0.8", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm"},
	"meck": {:hex, :meck, "0.8.13", "ffedb39f99b0b99703b8601c6f17c7f76313ee12de6b646e671e3188401f7866", [:rebar3], [], "hexpm"},
	"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm"},
	"mime": {:hex, :mime, "1.3.1", "30ce04ab3175b6ad0bdce0035cba77bba68b813d523d1aac73d9781b4d193cf8", [:mix], [], "hexpm"},
	"mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm"},
	"mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.3", "42a433794b1291a9cf1525c6d26b38e039e0d3a360732b5e467bfc77ef26c914", [:mix], [{:meck, "~> 0.8.13", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm"},
	"mogrify": {:hex, :mogrify, "0.6.1", "de1b527514f2d95a7bbe9642eb556061afb337e220cf97adbf3a4e6438ed70af", [:mix], [], "hexpm"},
	"mox": {:hex, :mox, "0.5.1", "f86bb36026aac1e6f924a4b6d024b05e9adbed5c63e8daa069bd66fb3292165b", [:mix], [], "hexpm"},
	"nimble_parsec": {:hex, :nimble_parsec, "0.5.0", "90e2eca3d0266e5c53f8fbe0079694740b9c91b6747f2b7e3c5d21966bba8300", [:mix], [], "hexpm"},
	"parse_trans": {:hex, :parse_trans, "3.3.0", "09765507a3c7590a784615cfd421d101aec25098d50b89d7aa1d66646bc571c1", [:rebar3], [], "hexpm"},
	"pbkdf2_elixir": {:hex, :pbkdf2_elixir, "0.12.3", "6706a148809a29c306062862c803406e88f048277f6e85b68faf73291e820b84", [:mix], [], "hexpm"},
	"phoenix": {:hex, :phoenix, "1.4.9", "746d098e10741c334d88143d3c94cab1756435f94387a63441792e66ec0ee974", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.8.1 or ~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "4.0.0", "c43117a136e7399ea04ecaac73f8f23ee0ffe3e07acfcb8062fe5f4c9f0f6531", [:mix], [{:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"phoenix_html": {:hex, :phoenix_html, "2.13.1", "fa8f034b5328e2dfa0e4131b5569379003f34bc1fafdaa84985b0b9d2f12e68b", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "1.1.2", "496c303bdf1b2e98a9d26e89af5bba3ab487ba3a3735f74bf1f4064d2a845a3e", [:mix], [], "hexpm"},
	"phoenix_swoosh": {:hex, :phoenix_swoosh, "0.2.0", "a7e0b32077cd6d2323ae15198839b05d9caddfa20663fd85787479e81f89520e", [:mix], [{:phoenix, "~> 1.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.2", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:swoosh, "~> 0.1", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm"},
	"pleroma_job_queue": {:hex, :pleroma_job_queue, "0.3.0", "b84538d621f0c3d6fcc1cff9d5648d3faaf873b8b21b94e6503428a07a48ec47", [:mix], [{:crontab, "~> 1.1", [hex: :crontab, repo: "hexpm", optional: false]}], "hexpm"},
	"plug": {:hex, :plug, "1.8.2", "0bcce1daa420f189a6491f3940cc77ea7fb1919761175c9c3b59800d897440fc", [:mix], [{:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.1.0", "b75768153c3a8a9e8039d4b25bb9b14efbc58e9c4a6e6a270abff1cd30cbe320", [:mix], [{:cowboy, "~> 2.5", [hex: :cowboy, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"plug_crypto": {:hex, :plug_crypto, "1.0.0", "18e49317d3fa343f24620ed22795ec29d4a5e602d52d1513ccea0b07d8ea7d4d", [:mix], [], "hexpm"},
	"plug_static_index_html": {:hex, :plug_static_index_html, "1.0.0", "840123d4d3975585133485ea86af73cb2600afd7f2a976f9f5fd8b3808e636a0", [:mix], [{:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm"},
	"postgrex": {:hex, :postgrex, "0.14.3", "5754dee2fdf6e9e508cbf49ab138df964278700b764177e8f3871e658b345a1e", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"},
	"prometheus": {:hex, :prometheus, "4.4.1", "1e96073b3ed7788053768fea779cbc896ddc3bdd9ba60687f2ad50b252ac87d6", [:mix, :rebar3], [], "hexpm"},
	"prometheus_ecto": {:hex, :prometheus_ecto, "1.4.1", "6c768ea9654de871e5b32fab2eac348467b3021604ebebbcbd8bcbe806a65ed5", [: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"},
	"prometheus_ex": {:hex, :prometheus_ex, "3.0.5", "fa58cfd983487fc5ead331e9a3e0aa622c67232b3ec71710ced122c4c453a02f", [:mix], [{:prometheus, "~> 4.0", [hex: :prometheus, repo: "hexpm", optional: false]}], "hexpm"},
	"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"},
	"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"},
	"quack": {:hex, :quack, "0.1.1", "cca7b4da1a233757fdb44b3334fce80c94785b3ad5a602053b7a002b5a8967bf", [:mix], [{:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: false]}, {:tesla, "~> 1.2.0", [hex: :tesla, repo: "hexpm", optional: false]}], "hexpm"},
	"ranch": {:hex, :ranch, "1.7.1", "6b1fab51b49196860b733a49c07604465a47bdb78aa10c1c16a3d199f7f8c881", [:rebar3], [], "hexpm"},
	"recon": {:git, "https://github.com/ferd/recon.git", "75d70c7c08926d2f24f1ee6de14ee50fe8a52763", [tag: "2.4.0"]},
	"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.4", "f0eafff810d2041e93f915ef59899c923f4568f4585904d010387ed74988e77b", [:make, :mix, :rebar3], [], "hexpm"},
	"sweet_xml": {:hex, :sweet_xml, "0.6.6", "fc3e91ec5dd7c787b6195757fbcf0abc670cee1e4172687b45183032221b66b8", [:mix], [], "hexpm"},
	"swoosh": {:hex, :swoosh, "0.23.2", "7dda95ff0bf54a2298328d6899c74dae1223777b43563ccebebb4b5d2b61df38", [:mix], [{:cowboy, "~> 1.0.1 or ~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}], "hexpm"},
	"syslog": {:git, "https://github.com/Vagabond/erlang-syslog.git", "4a6c6f2c996483e86c1320e9553f91d337bcb6aa", [tag: "1.0.5"]},
	"telemetry": {:hex, :telemetry, "0.4.0", "8339bee3fa8b91cb84d14c2935f8ecf399ccd87301ad6da6b71c09553834b2ab", [:rebar3], [], "hexpm"},
	"tesla": {:hex, :tesla, "1.2.1", "864783cc27f71dd8c8969163704752476cec0f3a51eb3b06393b3971dc9733ff", [:mix], [{:exjsx, ">= 3.0.0", [hex: :exjsx, repo: "hexpm", optional: true]}, {:fuse, "~> 2.4", [hex: :fuse, repo: "hexpm", optional: true]}, {:hackney, "~> 1.6", [hex: :hackney, repo: "hexpm", optional: true]}, {:ibrowse, "~> 4.4.0", [hex: :ibrowse, repo: "hexpm", optional: true]}, {:jason, ">= 1.0.0", [hex: :jason, repo: "hexpm", optional: true]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: true]}], "hexpm"},
	"timex": {:hex, :timex, "3.6.1", "efdf56d0e67a6b956cc57774353b0329c8ab7726766a11547e529357ffdc1d56", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 0.1.8 or ~> 0.5 or ~> 1.0.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm"},
	"trailing_format_plug": {:hex, :trailing_format_plug, "0.0.7", "64b877f912cf7273bed03379936df39894149e35137ac9509117e59866e10e45", [:mix], [{:plug, "> 0.12.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	- "tzdata": {:hex, :tzdata, "1.0.1", "f6027a331af7d837471248e62733c6ebee86a72e57c613aa071ebb1f750fc71a", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
	+ "tzdata": {:hex, :tzdata, "0.5.21", "8cbf3607fcce69636c672d5be2bbb08687fe26639a62bdcc283d267277db7cf0", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm"},
	"ueberauth": {:hex, :ueberauth, "0.6.1", "9e90d3337dddf38b1ca2753aca9b1e53d8a52b890191cdc55240247c89230412", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
	"unicode_util_compat": {:hex, :unicode_util_compat, "0.4.1", "d869e4c68901dd9531385bb0c8c40444ebf624e60b6962d95952775cac5e90cd", [:rebar3], [], "hexpm"},
	"unsafe": {:hex, :unsafe, "1.0.1", "a27e1874f72ee49312e0a9ec2e0b27924214a05e3ddac90e91727bc76f8613d8", [:mix], [], "hexpm"},
	"web_push_encryption": {:hex, :web_push_encryption, "0.2.1", "d42cecf73420d9dc0053ba3299cc8c8d6ff2be2487d67ca2a57265868e4d9a98", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.8", [hex: :jose, repo: "hexpm", optional: false]}, {:poison, "~> 3.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"},
	"websocket_client": {:git, "https://github.com/jeremyong/websocket_client.git", "9a6f65d05ebf2725d62fb19262b21f1805a59fbf", []},
	}
	diff --git a/test/config/transfer_task_test.exs b/test/config/transfer_task_test.exs
	index dbeadbe87..4455a4d47 100644
	--- a/test/config/transfer_task_test.exs
	+++ b/test/config/transfer_task_test.exs
	@@ -1,57 +1,57 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTaskTest do
	use Pleroma.DataCase

	setup do
	dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])

	Pleroma.Config.put([:instance, :dynamic_configuration], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
	end)
	end

	test "transfer config values from db to env" do
	refute Application.get_env(:pleroma, :test_key)
	refute Application.get_env(:idna, :test_key)

	Pleroma.Web.AdminAPI.Config.create(%{
	group: "pleroma",
	key: "test_key",
	value: [live: 2, com: 3]
	})

	Pleroma.Web.AdminAPI.Config.create(%{
	group: "idna",
	key: "test_key",
	value: [live: 15, com: 35]
	})

	- Pleroma.Config.TransferTask.start_link()
	+ Pleroma.Config.TransferTask.start_link([])

	assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
	assert Application.get_env(:idna, :test_key) == [live: 15, com: 35]

	on_exit(fn ->
	Application.delete_env(:pleroma, :test_key)
	Application.delete_env(:idna, :test_key)
	end)
	end

	test "non existing atom" do
	Pleroma.Web.AdminAPI.Config.create(%{
	group: "pleroma",
	key: "undefined_atom_key",
	value: [live: 2, com: 3]
	})

	assert ExUnit.CaptureLog.capture_log(fn ->
	- Pleroma.Config.TransferTask.start_link()
	+ Pleroma.Config.TransferTask.start_link([])
	end) =~
	"updating env causes error, key: \"undefined_atom_key\", error: %ArgumentError{message: \"argument error\"}"
	end
	end
	diff --git a/test/support/mrf_module_mock.ex b/test/support/mrf_module_mock.ex
	new file mode 100644
	index 000000000..12c7e22bc
	--- /dev/null
	+++ b/test/support/mrf_module_mock.ex
	@@ -0,0 +1,13 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule MRFModuleMock do
	+ @behaviour Pleroma.Web.ActivityPub.MRF
	+
	+ @impl true
	+ def filter(message), do: {:ok, message}
	+
	+ @impl true
	+ def describe, do: {:ok, %{mrf_module_mock: "some config data"}}
	+end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 8440d456d..b363b322c 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,1573 +1,1576 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserTest do
	alias Pleroma.Activity
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase

	import Pleroma.Factory
	import Mock

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "when tags are nil" do
	test "tagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.tag(user, ["cool", "dude"])

	assert "cool" in user.tags
	assert "dude" in user.tags
	end

	test "untagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.untag(user, ["cool", "dude"])

	assert user.tags == []
	end
	end

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "ap_following returns the following collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/following"

	assert expected_followers_collection == User.ap_following(user)
	end

	test "returns all pending follow requests" do
	unlocked = insert(:user)
	locked = insert(:user, %{info: %{locked: true}})
	follower = insert(:user)

	Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => unlocked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => locked.id})

	assert {:ok, []} = User.get_follow_requests(unlocked)
	assert {:ok, [activity]} = User.get_follow_requests(locked)

	assert activity
	end

	test "doesn't return already accepted or duplicate follow requests" do
	locked = insert(:user, %{info: %{locked: true}})
	pending_follower = insert(:user)
	accepted_follower = insert(:user)

	Pleroma.Web.TwitterAPI.TwitterAPI.follow(pending_follower, %{"user_id" => locked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(pending_follower, %{"user_id" => locked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(accepted_follower, %{"user_id" => locked.id})
	User.follow(accepted_follower, locked)

	assert {:ok, [activity]} = User.get_follow_requests(locked)
	assert activity
	end

	test "follow_all follows mutliple users" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	blocked = insert(:user)
	not_followed = insert(:user)
	reverse_blocked = insert(:user)

	{:ok, user} = User.block(user, blocked)
	{:ok, reverse_blocked} = User.block(reverse_blocked, user)

	{:ok, user} = User.follow(user, followed_zero)

	{:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])

	assert User.following?(user, followed_one)
	assert User.following?(user, followed_two)
	assert User.following?(user, followed_zero)
	refute User.following?(user, not_followed)
	refute User.following?(user, blocked)
	refute User.following?(user, reverse_blocked)
	end

	test "follow_all follows mutliple users without duplicating" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)

	{:ok, user} = User.follow_all(user, [followed_zero, followed_one])
	assert length(user.following) == 3

	{:ok, user} = User.follow_all(user, [followed_one, followed_two])
	assert length(user.following) == 4
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user} = User.follow(user, followed)

	user = User.get_cached_by_id(user.id)

	followed = User.get_cached_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	assert User.ap_followers(followed) in user.following
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, info: %{deactivated: true})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	test "can't subscribe to a user who blocked us" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.block(blocker, blocked)

	{:error, _} = User.subscribe(blocked, blocker)
	end

	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, info: %{locked: true})
	followed = insert(:user, info: %{locked: true})

	{:ok, follower} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	# This is a somewhat useless test.
	# test "following a remote user will ensure a websub subscription is present" do
	# user = insert(:user)
	# {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")

	# assert followed.local == false

	# {:ok, user} = User.follow(user, followed)
	# assert User.ap_followers(followed) in user.following

	# query = from w in WebsubClientSubscription,
	# where: w.topic == ^followed.info["topic"]
	# websub = Repo.one(query)

	# assert websub
	# end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	{:ok, user, _activity} = User.unfollow(user, followed)

	user = User.get_cached_by_id(user.id)

	assert user.following == []
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	user = User.get_cached_by_id(user.id)
	assert user.following == [user.ap_id]
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	test "fetches correct profile for nickname beginning with number" do
	# Use old-style integer ID to try to reproduce the problem
	user = insert(:user, %{id: 1080})
	user_with_numbers = insert(:user, %{nickname: "#{user.id}garbage"})
	assert user_with_numbers == User.get_cached_by_nickname_or_id(user_with_numbers.nickname)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	test "it autofollows accounts that are set for it" do
	user = insert(:user)
	remote_user = insert(:user, %{local: false})

	Pleroma.Config.put([:instance, :autofollowed_nicknames], [
	user.nickname,
	remote_user.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(registered_user, user)
	refute User.following?(registered_user, remote_user)

	Pleroma.Config.put([:instance, :autofollowed_nicknames], [])
	end

	test "it sends a welcome message if it is set" do
	welcome_user = insert(:user)

	Pleroma.Config.put([:instance, :welcome_user_nickname], welcome_user.nickname)
	Pleroma.Config.put([:instance, :welcome_message], "Hello, this is a cool site")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert Object.normalize(activity).data["content"] =~ "cool site"
	assert activity.actor == welcome_user.ap_id

	Pleroma.Config.put([:instance, :welcome_user_nickname], nil)
	Pleroma.Config.put([:instance, :welcome_message], nil)
	end

	test "it requires an email, name, nickname and password, bio is optional" do
	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it restricts certain nicknames" do
	[restricted_name \| _] = Pleroma.Config.get([User, :restricted_nicknames])

	assert is_bitstring(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_name)

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

	refute changeset.valid?
	end

	test "it sets the password_hash, ap_id and following fields" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})

	assert changeset.changes[:following] == [
	User.ap_followers(%User{nickname: @full_user_data.nickname})
	]

	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end

	test "it ensures info is not nil" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	{:ok, user} =
	changeset
	\|> Repo.insert()

	refute is_nil(user.info)
	end
	end

	describe "user registration, with :account_activation_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	:ok
	end

	test "it creates unconfirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	assert user.info.confirmation_pending
	assert user.info.confirmation_token
	end

	test "it creates confirmed user if :confirmed option is given" do
	changeset = User.register_changeset(%User{}, @full_user_data, need_confirmation: false)
	assert changeset.valid?

	{:ok, user} = Repo.insert(changeset)

	refute user.info.confirmation_pending
	refute user.info.confirmation_token
	end
	end

	describe "get_or_fetch/1" do
	test "gets an existing user by nickname" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user by ap_id" do
	ap_id = "http://mastodon.example.org/users/admin"

	user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: ap_id,
	info: %{}
	)

	{:ok, fetched_user} = User.get_or_fetch(ap_id)
	freshed_user = refresh_record(user)
	assert freshed_user == fetched_user
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	{:ok, fetched_user} = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	{:ok, fetched_user} = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname" do
	user = insert(:user)

	{:ok, fetched_user} =
	User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname, case insensitive" do
	user = insert(:user, nickname: "nick")
	casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	{:ok, fetched_user} = User.get_or_fetch_by_nickname(casing_altered_fqn)

	assert user == fetched_user
	end

	test "fetches an external user via ostatus if no user exists" do
	{:ok, fetched_user} = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
	assert fetched_user.nickname == "shp@social.heldscal.la"
	end

	test "returns nil if no user could be fetched" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == "not found nonexistant@social.heldscal.la"
	end

	test "returns nil for nonexistant local user" do
	{:error, fetched_user} = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == "not found nonexistant"
	end

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago,
	info: %{}
	)

	assert orig_user.last_refreshed_at == a_week_ago

	{:ok, user} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
	assert user.info.source_data["endpoints"]

	refute user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user creation changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	info: %{some: "info"},
	avatar: %{some: "avatar"}
	}

	test "it confirms validity" do
	cs = User.remote_user_creation(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_creation(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_creation(%{@valid_remote \| nickname: "bla"})
	assert cs.changes.local == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:name, :ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_creation(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it restricts some sizes" do
	- [bio: 5000, name: 100]
	+ bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	+ name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)
	+
	+ [bio: bio_limit, name: name_limit]
	\|> Enum.each(fn {field, size} ->
	string = String.pad_leading(".", size)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	assert cs.valid?

	string = String.pad_leading(".", size + 1)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	refute cs.valid?
	end)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one} = User.follow(follower_one, user)
	{:ok, follower_two} = User.follow(follower_two, user)

	{:ok, res} = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

	{:ok, res} = User.get_friends(user)

	followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
	followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the info->note_count property" do
	note = insert(:note)

	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.update_note_count(user)

	assert user.info.note_count == 1
	end

	test "it increases the info->note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 2
	end

	test "it decreases the info->note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 1

	{:ok, user} = User.decrease_note_count(user)

	assert user.info.note_count == 0

	{:ok, user} = User.decrease_note_count(user)

	assert user.info.note_count == 0
	end

	test "it sets the info->follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.info.follower_count == 0

	{:ok, user} = User.update_follower_count(user)

	assert user.info.follower_count == 1
	end
	end

	describe "remove duplicates from following list" do
	test "it removes duplicates" do
	user = insert(:user)
	follower = insert(:user)

	{:ok, %User{following: following} = follower} = User.follow(follower, user)
	assert length(following) == 2

	{:ok, follower} =
	follower
	\|> User.update_changeset(%{following: following ++ following})
	\|> Repo.update()

	assert length(follower.following) == 4

	{:ok, follower} = User.remove_duplicated_following(follower)
	assert length(follower.following) == 2
	end

	test "it does nothing when following is uniq" do
	user = insert(:user)
	follower = insert(:user)

	{:ok, follower} = User.follow(follower, user)
	assert length(follower.following) == 2

	{:ok, follower} = User.remove_duplicated_following(follower)
	assert length(follower.following) == 2
	end
	end

	describe "follow_import" do
	test "it imports user followings from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	result = User.follow_import(user1, identifiers)
	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	describe "mutes" do
	test "it mutes people" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

	{:ok, user} = User.mute(user, muted_user)

	assert User.mutes?(user, muted_user)
	assert User.muted_notifications?(user, muted_user)
	end

	test "it unmutes users" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, user} = User.mute(user, muted_user)
	{:ok, user} = User.unmute(user, muted_user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end

	test "it mutes user without notifications" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)

	{:ok, user} = User.mute(user, muted_user, false)

	assert User.mutes?(user, muted_user)
	refute User.muted_notifications?(user, muted_user)
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

	{:ok, user} = User.block(user, blocked_user)

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, user} = User.block(user, blocked_user)
	{:ok, user} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker subscription relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.subscribe(blocked, blocker)

	assert User.subscribed_to?(blocked, blocker)
	refute User.subscribed_to?(blocker, blocked)

	{:ok, blocker} = User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	refute User.subscribed_to?(blocker, blocked)
	refute User.subscribed_to?(blocked, blocker)
	end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "does not block domain with same end if wildcard added" do
	user = insert(:user)

	collateral_user =
	insert(:user, %{ap_id: "https://another-awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end

	test "blocks domain with wildcard for subdomain" do
	user = insert(:user)

	user_from_subdomain =
	insert(:user, %{ap_id: "https://subdomain.awful-and-rude-instance.com/user/bully"})

	user_with_two_subdomains =
	insert(:user, %{
	ap_id: "https://subdomain.second_subdomain.awful-and-rude-instance.com/user/bully"
	})

	user_domain = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "*.awful-and-rude-instance.com")

	assert User.blocks?(user, user_from_subdomain)
	assert User.blocks?(user, user_with_two_subdomains)
	assert User.blocks?(user, user_domain)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end
	end

	describe "blocks_import" do
	test "it imports user blocks from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	result = User.blocks_import(user1, identifiers)
	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	test "get recipients from activity" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, user} = User.follow(user, actor)
	{:ok, _user_two} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 3
	assert user in recipients
	assert addressed in recipients
	end

	describe ".deactivate" do
	test "can de-activate then re-activate a user" do
	user = insert(:user)
	assert false == user.info.deactivated
	{:ok, user} = User.deactivate(user)
	assert true == user.info.deactivated
	{:ok, user} = User.deactivate(user, false)
	assert false == user.info.deactivated
	end

	test "hide a user from followers " do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user} = User.follow(user, user2)
	{:ok, _user} = User.deactivate(user)

	info = User.get_cached_user_info(user2)

	assert info.follower_count == 0
	assert {:ok, []} = User.get_followers(user2)
	end

	test "hide a user from friends" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2} = User.follow(user2, user)
	assert User.following_count(user2) == 1

	{:ok, _user} = User.deactivate(user)

	info = User.get_cached_user_info(user2)

	assert info.following_count == 0
	assert User.following_count(user2) == 0
	assert {:ok, []} = User.get_friends(user2)
	end

	test "hide a user's statuses from timelines and notifications" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, user2} = User.follow(user2, user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{user2.nickname}"})

	activity = Repo.preload(activity, :bookmark)

	[notification] = Pleroma.Notification.for_user(user2)
	assert notification.activity.id == activity.id

	assert [activity] == ActivityPub.fetch_public_activities(%{}) \|> Repo.preload(:bookmark)

	assert [%{activity \| thread_muted?: CommonAPI.thread_muted?(user2, activity)}] ==
	ActivityPub.fetch_activities([user2.ap_id \| user2.following], %{"user" => user2})

	{:ok, _user} = User.deactivate(user)

	assert [] == ActivityPub.fetch_public_activities(%{})
	assert [] == Pleroma.Notification.for_user(user2)

	assert [] ==
	ActivityPub.fetch_activities([user2.ap_id \| user2.following], %{"user" => user2})
	end
	end

	describe "delete" do
	setup do
	{:ok, user} = insert(:user) \|> User.set_cache()

	[user: user]
	end

	test ".delete_user_activities deletes all create activities", %{user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})

	{:ok, _} = User.delete_user_activities(user)

	# TODO: Remove favorites, repeats, delete activities.
	refute Activity.get_by_id(activity.id)
	end

	test "it deletes a user, all follow relationships and all activities", %{user: user} do
	follower = insert(:user)
	{:ok, follower} = User.follow(follower, user)

	object = insert(:note, user: user)
	activity = insert(:note_activity, user: user, note: object)

	object_two = insert(:note, user: follower)
	activity_two = insert(:note_activity, user: follower, note: object_two)

	{:ok, like, _} = CommonAPI.favorite(activity_two.id, user)
	{:ok, like_two, _} = CommonAPI.favorite(activity.id, follower)
	{:ok, repeat, _} = CommonAPI.repeat(activity_two.id, user)

	{:ok, _} = User.delete(user)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	refute User.get_by_id(user.id)
	assert {:ok, nil} == Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	user_activities =
	user.ap_id
	\|> Activity.query_by_actor()
	\|> Repo.all()
	\|> Enum.map(fn act -> act.data["type"] end)

	assert Enum.all?(user_activities, fn act -> act in ~w(Delete Undo) end)

	refute Activity.get_by_id(activity.id)
	refute Activity.get_by_id(like.id)
	refute Activity.get_by_id(like_two.id)
	refute Activity.get_by_id(repeat.id)
	end

	test_with_mock "it sends out User Delete activity",
	%{user: user},
	Pleroma.Web.ActivityPub.Publisher,
	[:passthrough],
	[] do
	config_path = [:instance, :federating]
	initial_setting = Pleroma.Config.get(config_path)
	Pleroma.Config.put(config_path, true)

	{:ok, follower} = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
	{:ok, _} = User.follow(follower, user)

	{:ok, _user} = User.delete(user)

	assert called(
	Pleroma.Web.ActivityPub.Publisher.publish_one(%{
	inbox: "http://mastodon.example.org/inbox"
	})
	)

	Pleroma.Config.put(config_path, initial_setting)
	end
	end

	test "get_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	test "insert or update a user from given data" do
	user = insert(:user, %{nickname: "nick@name.de"})
	data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns default policies, when rich-text is enabled" do
	user = insert(:user)

	assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, %{info: %{no_rich_text: true}})

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)
	_user_info = User.get_cached_user_info(user)

	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	{:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

	{:ok, _} = User.delete(user)

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	test "auth_active?/1 works correctly" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	local_user = insert(:user, local: true, info: %{confirmation_pending: true})
	confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
	remote_user = insert(:user, local: false)

	refute User.auth_active?(local_user)
	assert User.auth_active?(confirmed_user)
	assert User.auth_active?(remote_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end

	describe "superuser?/1" do
	test "returns false for unprivileged users" do
	user = insert(:user, local: true)

	refute User.superuser?(user)
	end

	test "returns false for remote users" do
	user = insert(:user, local: false)
	remote_admin_user = insert(:user, local: false, info: %{is_admin: true})

	refute User.superuser?(user)
	refute User.superuser?(remote_admin_user)
	end

	test "returns true for local moderators" do
	user = insert(:user, local: true, info: %{is_moderator: true})

	assert User.superuser?(user)
	end

	test "returns true for local admins" do
	user = insert(:user, local: true, info: %{is_admin: true})

	assert User.superuser?(user)
	end
	end

	describe "visible_for?/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for?(user, user)
	end

	test "returns false when the account is unauthenticated and auth is required" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true)

	refute User.visible_for?(user, other_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end

	test "returns true when the account is unauthenticated and auth is not required" do
	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true)

	assert User.visible_for?(user, other_user)
	end

	test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true, info: %{is_admin: true})

	assert User.visible_for?(user, other_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	"A.k.a. <span class='h-card'><a data-user='#{remote_user.id}' class='u-url mention' href='#{
	remote_user.ap_id
	}'>@<span>nick@domain.com</span></a></span>"

	assert expected_text == User.parse_bio(bio, user)
	end

	test "Adds rel=me on linkbacked urls" do
	user = insert(:user, ap_id: "http://social.example.org/users/lain")

	bio = "http://example.org/rel_me/null"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.org/rel_me/link"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.org/rel_me/anchor"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "follower count is updated when a follower is blocked" do
	user = insert(:user)
	follower = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)

	{:ok, follower} = User.follow(follower, user)
	{:ok, _follower2} = User.follow(follower2, user)
	{:ok, _follower3} = User.follow(follower3, user)

	{:ok, _} = User.block(user, follower)

	user_show = Pleroma.Web.TwitterAPI.UserView.render("show.json", %{user: user})

	assert Map.get(user_show, "followers_count") == 2
	end

	describe "list_inactive_users_query/1" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Users are inactive by default" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(users, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users who has no recent activity" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
	end)

	{inactive, active} = Enum.split(users, trunc(total / 2))

	Enum.map(active, fn user ->
	to = Enum.random(users -- [user])

	{:ok, _} =
	Pleroma.Web.TwitterAPI.TwitterAPI.create_status(user, %{
	"status" => "hey @#{to.nickname}"
	})
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end

	test "Only includes users with no read notifications" do
	total = 10

	users =
	Enum.map(1..total, fn _ ->
	insert(:user, last_digest_emailed_at: days_ago(20), info: %{deactivated: false})
	end)

	[sender \| recipients] = users
	{inactive, active} = Enum.split(recipients, trunc(total / 2))

	Enum.each(recipients, fn to ->
	{:ok, _} =
	Pleroma.Web.TwitterAPI.TwitterAPI.create_status(sender, %{
	"status" => "hey @#{to.nickname}"
	})

	{:ok, _} =
	Pleroma.Web.TwitterAPI.TwitterAPI.create_status(sender, %{
	"status" => "hey again @#{to.nickname}"
	})
	end)

	Enum.each(active, fn user ->
	[n1, _n2] = Pleroma.Notification.for_user(user)
	{:ok, _} = Pleroma.Notification.read_one(user, n1.id)
	end)

	inactive_users_ids =
	Pleroma.User.list_inactive_users_query()
	\|> Pleroma.Repo.all()
	\|> Enum.map(& &1.id)

	Enum.each(active, fn user ->
	refute user.id in inactive_users_ids
	end)

	Enum.each(inactive, fn user ->
	assert user.id in inactive_users_ids
	end)
	end
	end

	describe "toggle_confirmation/1" do
	test "if user is confirmed" do
	user = insert(:user, info: %{confirmation_pending: false})
	{:ok, user} = User.toggle_confirmation(user)

	assert user.info.confirmation_pending
	assert user.info.confirmation_token
	end

	test "if user is unconfirmed" do
	user = insert(:user, info: %{confirmation_pending: true, confirmation_token: "some token"})
	{:ok, user} = User.toggle_confirmation(user)

	refute user.info.confirmation_pending
	refute user.info.confirmation_token
	end
	end

	describe "ensure_keys_present" do
	test "it creates keys for a user and stores them in info" do
	user = insert(:user)
	refute is_binary(user.info.keys)
	{:ok, user} = User.ensure_keys_present(user)
	assert is_binary(user.info.keys)
	end

	test "it doesn't create keys if there already are some" do
	user = insert(:user, %{info: %{keys: "xxx"}})
	{:ok, user} = User.ensure_keys_present(user)
	assert user.info.keys == "xxx"
	end
	end

	describe "get_ap_ids_by_nicknames" do
	test "it returns a list of AP ids for a given set of nicknames" do
	user = insert(:user)
	user_two = insert(:user)

	ap_ids = User.get_ap_ids_by_nicknames([user.nickname, user_two.nickname, "nonexistent"])
	assert length(ap_ids) == 2
	assert user.ap_id in ap_ids
	assert user_two.ap_id in ap_ids
	end
	end

	describe "sync followers count" do
	setup do
	user1 = insert(:user, local: false, ap_id: "http://localhost:4001/users/masto_closed")
	user2 = insert(:user, local: false, ap_id: "http://localhost:4001/users/fuser2")
	insert(:user, local: true)
	insert(:user, local: false, info: %{deactivated: true})
	{:ok, user1: user1, user2: user2}
	end

	test "external_users/1 external active users with limit", %{user1: user1, user2: user2} do
	[fdb_user1] = User.external_users(limit: 1)

	assert fdb_user1.ap_id
	assert fdb_user1.ap_id == user1.ap_id
	assert fdb_user1.id == user1.id

	[fdb_user2] = User.external_users(max_id: fdb_user1.id, limit: 1)

	assert fdb_user2.ap_id
	assert fdb_user2.ap_id == user2.ap_id
	assert fdb_user2.id == user2.id

	assert User.external_users(max_id: fdb_user2.id, limit: 1) == []
	end
	end

	describe "set_info_cache/2" do
	setup do
	user = insert(:user)
	{:ok, user: user}
	end

	test "update from args", %{user: user} do
	User.set_info_cache(user, %{following_count: 15, follower_count: 18})

	%{follower_count: followers, following_count: following} = User.get_cached_user_info(user)
	assert followers == 18
	assert following == 15
	end

	test "without args", %{user: user} do
	User.set_info_cache(user, %{})

	%{follower_count: followers, following_count: following} = User.get_cached_user_info(user)
	assert followers == 0
	assert following == 0
	end
	end

	describe "user_info/2" do
	setup do
	user = insert(:user)
	{:ok, user: user}
	end

	test "update from args", %{user: user} do
	%{follower_count: followers, following_count: following} =
	User.user_info(user, %{following_count: 15, follower_count: 18})

	assert followers == 18
	assert following == 15
	end

	test "without args", %{user: user} do
	%{follower_count: followers, following_count: following} = User.user_info(user)

	assert followers == 0
	assert following == 0
	end
	end

	describe "is_internal_user?/1" do
	test "non-internal user returns false" do
	user = insert(:user)
	refute User.is_internal_user?(user)
	end

	test "user with no nickname returns true" do
	user = insert(:user, %{nickname: nil})
	assert User.is_internal_user?(user)
	end

	test "user with internal-prefixed nickname returns true" do
	user = insert(:user, %{nickname: "internal.test"})
	assert User.is_internal_user?(user)
	end
	end

	describe "update_and_set_cache/1" do
	test "returns error when user is stale instead Ecto.StaleEntryError" do
	user = insert(:user)

	changeset = Ecto.Changeset.change(user, bio: "test")

	Repo.delete(user)

	assert {:error, %Ecto.Changeset{errors: [id: {"is stale", [stale: true]}], valid?: false}} =
	User.update_and_set_cache(changeset)
	end

	test "performs update cache if user updated" do
	user = insert(:user)
	assert {:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	changeset = Ecto.Changeset.change(user, bio: "test-bio")

	assert {:ok, %User{bio: "test-bio"} = user} = User.update_and_set_cache(changeset)
	assert {:ok, user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	assert %User{bio: "test-bio"} = User.get_cached_by_ap_id(user.ap_id)
	end
	end

	describe "following/followers synchronization" do
	setup do
	sync = Pleroma.Config.get([:instance, :external_user_synchronization])
	on_exit(fn -> Pleroma.Config.put([:instance, :external_user_synchronization], sync) end)
	end

	test "updates the counters normally on following/getting a follow when disabled" do
	Pleroma.Config.put([:instance, :external_user_synchronization], false)
	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	info: %{ap_enabled: true}
	)

	assert User.user_info(other_user).following_count == 0
	assert User.user_info(other_user).follower_count == 0

	{:ok, user} = Pleroma.User.follow(user, other_user)
	other_user = Pleroma.User.get_by_id(other_user.id)

	assert User.user_info(user).following_count == 1
	assert User.user_info(other_user).follower_count == 1
	end

	test "syncronizes the counters with the remote instance for the followed when enabled" do
	Pleroma.Config.put([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	info: %{ap_enabled: true}
	)

	assert User.user_info(other_user).following_count == 0
	assert User.user_info(other_user).follower_count == 0

	Pleroma.Config.put([:instance, :external_user_synchronization], true)
	{:ok, _user} = User.follow(user, other_user)
	other_user = User.get_by_id(other_user.id)

	assert User.user_info(other_user).follower_count == 437
	end

	test "syncronizes the counters with the remote instance for the follower when enabled" do
	Pleroma.Config.put([:instance, :external_user_synchronization], false)

	user = insert(:user)

	other_user =
	insert(:user,
	local: false,
	follower_address: "http://localhost:4001/users/masto_closed/followers",
	following_address: "http://localhost:4001/users/masto_closed/following",
	info: %{ap_enabled: true}
	)

	assert User.user_info(other_user).following_count == 0
	assert User.user_info(other_user).follower_count == 0

	Pleroma.Config.put([:instance, :external_user_synchronization], true)
	{:ok, other_user} = User.follow(other_user, user)

	assert User.user_info(other_user).following_count == 152
	end
	end
	end
	diff --git a/test/web/activity_pub/mrf/mrf_test.exs b/test/web/activity_pub/mrf/mrf_test.exs
	index 1a888e18f..19e172939 100644
	--- a/test/web/activity_pub/mrf/mrf_test.exs
	+++ b/test/web/activity_pub/mrf/mrf_test.exs
	@@ -1,60 +1,86 @@
	defmodule Pleroma.Web.ActivityPub.MRFTest do
	use ExUnit.Case, async: true
	alias Pleroma.Web.ActivityPub.MRF

	test "subdomains_regex/1" do
	assert MRF.subdomains_regex(["unsafe.tld", "*.unsafe.tld"]) == [
	~r/^unsafe.tld$/i,
	~r/^(.\.)unsafe.tld$/i
	]
	end

	describe "subdomain_match/2" do
	test "common domains" do
	regexes = MRF.subdomains_regex(["unsafe.tld", "unsafe2.tld"])

	assert regexes == [~r/^unsafe.tld$/i, ~r/^unsafe2.tld$/i]

	assert MRF.subdomain_match?(regexes, "unsafe.tld")
	assert MRF.subdomain_match?(regexes, "unsafe2.tld")

	refute MRF.subdomain_match?(regexes, "example.com")
	end

	test "wildcard domains with one subdomain" do
	regexes = MRF.subdomains_regex(["*.unsafe.tld"])

	assert regexes == [~r/^(.\.)unsafe.tld$/i]

	assert MRF.subdomain_match?(regexes, "unsafe.tld")
	assert MRF.subdomain_match?(regexes, "sub.unsafe.tld")
	refute MRF.subdomain_match?(regexes, "anotherunsafe.tld")
	refute MRF.subdomain_match?(regexes, "unsafe.tldanother")
	end

	test "wildcard domains with two subdomains" do
	regexes = MRF.subdomains_regex(["*.unsafe.tld"])

	assert regexes == [~r/^(.\.)unsafe.tld$/i]

	assert MRF.subdomain_match?(regexes, "unsafe.tld")
	assert MRF.subdomain_match?(regexes, "sub.sub.unsafe.tld")
	refute MRF.subdomain_match?(regexes, "sub.anotherunsafe.tld")
	refute MRF.subdomain_match?(regexes, "sub.unsafe.tldanother")
	end

	test "matches are case-insensitive" do
	regexes = MRF.subdomains_regex(["UnSafe.TLD", "UnSAFE2.Tld"])

	assert regexes == [~r/^UnSafe.TLD$/i, ~r/^UnSAFE2.Tld$/i]

	assert MRF.subdomain_match?(regexes, "UNSAFE.TLD")
	assert MRF.subdomain_match?(regexes, "UNSAFE2.TLD")
	assert MRF.subdomain_match?(regexes, "unsafe.tld")
	assert MRF.subdomain_match?(regexes, "unsafe2.tld")

	refute MRF.subdomain_match?(regexes, "EXAMPLE.COM")
	refute MRF.subdomain_match?(regexes, "example.com")
	end
	end
	+
	+ describe "describe/0" do
	+ test "it works as expected with noop policy" do
	+ expected = %{
	+ mrf_policies: ["NoOpPolicy"],
	+ exclusions: false
	+ }
	+
	+ {:ok, ^expected} = MRF.describe()
	+ end
	+
	+ test "it works as expected with mock policy" do
	+ config = Pleroma.Config.get([:instance, :rewrite_policy])
	+ Pleroma.Config.put([:instance, :rewrite_policy], [MRFModuleMock])
	+
	+ expected = %{
	+ mrf_policies: ["MRFModuleMock"],
	+ mrf_module_mock: "some config data",
	+ exclusions: false
	+ }
	+
	+ {:ok, ^expected} = MRF.describe()
	+
	+ Pleroma.Config.put([:instance, :rewrite_policy], config)
	+ end
	+ end
	end
	diff --git a/test/web/activity_pub/mrf/vocabulary_policy_test.exs b/test/web/activity_pub/mrf/vocabulary_policy_test.exs
	new file mode 100644
	index 000000000..c3b11d7a1
	--- /dev/null
	+++ b/test/web/activity_pub/mrf/vocabulary_policy_test.exs
	@@ -0,0 +1,123 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.MRF.VocabularyPolicyTest do
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Web.ActivityPub.MRF.VocabularyPolicy
	+
	+ describe "accept" do
	+ test "it accepts based on parent activity type" do
	+ config = Pleroma.Config.get([:mrf_vocabulary, :accept])
	+ Pleroma.Config.put([:mrf_vocabulary, :accept], ["Like"])
	+
	+ message = %{
	+ "type" => "Like",
	+ "object" => "whatever"
	+ }
	+
	+ {:ok, ^message} = VocabularyPolicy.filter(message)
	+
	+ Pleroma.Config.put([:mrf_vocabulary, :accept], config)
	+ end
	+
	+ test "it accepts based on child object type" do
	+ config = Pleroma.Config.get([:mrf_vocabulary, :accept])
	+ Pleroma.Config.put([:mrf_vocabulary, :accept], ["Create", "Note"])
	+
	+ message = %{
	+ "type" => "Create",
	+ "object" => %{
	+ "type" => "Note",
	+ "content" => "whatever"
	+ }
	+ }
	+
	+ {:ok, ^message} = VocabularyPolicy.filter(message)
	+
	+ Pleroma.Config.put([:mrf_vocabulary, :accept], config)
	+ end
	+
	+ test "it does not accept disallowed child objects" do
	+ config = Pleroma.Config.get([:mrf_vocabulary, :accept])
	+ Pleroma.Config.put([:mrf_vocabulary, :accept], ["Create", "Note"])
	+
	+ message = %{
	+ "type" => "Create",
	+ "object" => %{
	+ "type" => "Article",
	+ "content" => "whatever"
	+ }
	+ }
	+
	+ {:reject, nil} = VocabularyPolicy.filter(message)
	+
	+ Pleroma.Config.put([:mrf_vocabulary, :accept], config)
	+ end
	+
	+ test "it does not accept disallowed parent types" do
	+ config = Pleroma.Config.get([:mrf_vocabulary, :accept])
	+ Pleroma.Config.put([:mrf_vocabulary, :accept], ["Announce", "Note"])
	+
	+ message = %{
	+ "type" => "Create",
	+ "object" => %{
	+ "type" => "Note",
	+ "content" => "whatever"
	+ }
	+ }
	+
	+ {:reject, nil} = VocabularyPolicy.filter(message)
	+
	+ Pleroma.Config.put([:mrf_vocabulary, :accept], config)
	+ end
	+ end
	+
	+ describe "reject" do
	+ test "it rejects based on parent activity type" do
	+ config = Pleroma.Config.get([:mrf_vocabulary, :reject])
	+ Pleroma.Config.put([:mrf_vocabulary, :reject], ["Like"])
	+
	+ message = %{
	+ "type" => "Like",
	+ "object" => "whatever"
	+ }
	+
	+ {:reject, nil} = VocabularyPolicy.filter(message)
	+
	+ Pleroma.Config.put([:mrf_vocabulary, :reject], config)
	+ end
	+
	+ test "it rejects based on child object type" do
	+ config = Pleroma.Config.get([:mrf_vocabulary, :reject])
	+ Pleroma.Config.put([:mrf_vocabulary, :reject], ["Note"])
	+
	+ message = %{
	+ "type" => "Create",
	+ "object" => %{
	+ "type" => "Note",
	+ "content" => "whatever"
	+ }
	+ }
	+
	+ {:reject, nil} = VocabularyPolicy.filter(message)
	+
	+ Pleroma.Config.put([:mrf_vocabulary, :reject], config)
	+ end
	+
	+ test "it passes through objects that aren't disallowed" do
	+ config = Pleroma.Config.get([:mrf_vocabulary, :reject])
	+ Pleroma.Config.put([:mrf_vocabulary, :reject], ["Like"])
	+
	+ message = %{
	+ "type" => "Announce",
	+ "object" => "whatever"
	+ }
	+
	+ {:ok, ^message} = VocabularyPolicy.filter(message)
	+
	+ Pleroma.Config.put([:mrf_vocabulary, :reject], config)
	+ end
	+ end
	+end
	diff --git a/test/web/activity_pub/relay_test.exs b/test/web/activity_pub/relay_test.exs
	index 21a63c493..e10b808f7 100644
	--- a/test/web/activity_pub/relay_test.exs
	+++ b/test/web/activity_pub/relay_test.exs
	@@ -1,15 +1,75 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.RelayTest do
	use Pleroma.DataCase

	+ alias Pleroma.Activity
	+ alias Pleroma.Object
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Relay

	+ import Pleroma.Factory
	+
	test "gets an actor for the relay" do
	user = Relay.get_actor()
	+ assert user.ap_id == "#{Pleroma.Web.Endpoint.url()}/relay"
	+ end
	+
	+ describe "follow/1" do
	+ test "returns errors when user not found" do
	+ assert Relay.follow("test-ap-id") == {:error, "Could not fetch by AP id"}
	+ end
	+
	+ test "returns activity" do
	+ user = insert(:user)
	+ service_actor = Relay.get_actor()
	+ assert {:ok, %Activity{} = activity} = Relay.follow(user.ap_id)
	+ assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	+ assert user.ap_id in activity.recipients
	+ assert activity.data["type"] == "Follow"
	+ assert activity.data["actor"] == service_actor.ap_id
	+ assert activity.data["object"] == user.ap_id
	+ end
	+ end
	+
	+ describe "unfollow/1" do
	+ test "returns errors when user not found" do
	+ assert Relay.unfollow("test-ap-id") == {:error, "Could not fetch by AP id"}
	+ end
	+
	+ test "returns activity" do
	+ user = insert(:user)
	+ service_actor = Relay.get_actor()
	+ ActivityPub.follow(service_actor, user)
	+ assert {:ok, %Activity{} = activity} = Relay.unfollow(user.ap_id)
	+ assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
	+ assert user.ap_id in activity.recipients
	+ assert activity.data["type"] == "Undo"
	+ assert activity.data["actor"] == service_actor.ap_id
	+ assert activity.data["to"] == [user.ap_id]
	+ end
	+ end
	+
	+ describe "publish/1" do
	+ test "returns error when activity not `Create` type" do
	+ activity = insert(:like_activity)
	+ assert Relay.publish(activity) == {:error, "Not implemented"}
	+ end
	+
	+ test "returns error when activity not public" do
	+ activity = insert(:direct_note_activity)
	+ assert Relay.publish(activity) == {:error, false}
	+ end

	- assert user.ap_id =~ "/relay"
	+ test "returns announce activity" do
	+ service_actor = Relay.get_actor()
	+ note = insert(:note_activity)
	+ assert {:ok, %Activity{} = activity, %Object{} = obj} = Relay.publish(note)
	+ assert activity.data["type"] == "Announce"
	+ assert activity.data["actor"] == service_actor.ap_id
	+ assert activity.data["object"] == obj.data["id"]
	+ end
	end
	end
	diff --git a/test/web/mastodon_api/mastodon_api_controller_test.exs b/test/web/mastodon_api/mastodon_api_controller_test.exs
	index b023d1e4f..112e272f9 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,3950 +1,4031 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Ecto.Changeset
	alias Pleroma.Activity
	+ alias Pleroma.Config
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.FilterView
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.Push
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock
	import Swoosh.TestAssertions

	@image "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "the home timeline", %{conn: conn} do
	user = insert(:user)
	following = insert(:user)

	{:ok, _activity} = CommonAPI.post(following, %{"status" => "test"})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert Enum.empty?(json_response(conn, 200))

	{:ok, user} = User.follow(user, following)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end

	test "the public timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, _activity} = CommonAPI.post(following, %{"status" => "test"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	conn =
	conn
	\|> get("/api/v1/timelines/public", %{"local" => "False"})

	assert length(json_response(conn, 200)) == 2

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "True"})

	assert [%{"content" => "test"}] = json_response(conn, 200)

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "1"})

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end)
	end

	test "the public timeline when public is set to false", %{conn: conn} do
	- public = Pleroma.Config.get([:instance, :public])
	- Pleroma.Config.put([:instance, :public], false)
	+ public = Config.get([:instance, :public])
	+ Config.put([:instance, :public], false)

	on_exit(fn ->
	- Pleroma.Config.put([:instance, :public], public)
	+ Config.put([:instance, :public], public)
	end)

	assert conn
	\|> get("/api/v1/timelines/public", %{"local" => "False"})
	\|> json_response(403) == %{"error" => "This resource requires authentication."}
	end

	describe "posting statuses" do
	setup do
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, user)

	[conn: conn]
	end

	test "posting a status", %{conn: conn} do
	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	{:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
	# Six hours
	assert ttl > :timer.seconds(6 * 60 * 60 - 1)

	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response(conn_one, 200)

	assert Activity.get_by_id(id)

	conn_two =
	conn
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => second_id} = json_response(conn_two, 200)
	assert id == second_id

	conn_three =
	conn
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => third_id} = json_response(conn_three, 200)
	refute id == third_id
	end

	test "replying to a status", %{conn: conn} do
	user = insert(:user)
	{:ok, replied_to} = CommonAPI.post(user, %{"status" => "cofe"})

	conn =
	conn
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Activity.get_by_id(id)

	assert activity.data["context"] == replied_to.data["context"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
	end

	test "replying to a direct message with visibility other than direct", %{conn: conn} do
	user = insert(:user)
	{:ok, replied_to} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	conn =
	conn
	\|> post("/api/v1/statuses", %{
	"status" => "@#{user.nickname} hey",
	"in_reply_to_id" => replied_to.id,
	"visibility" => visibility
	})

	assert json_response(conn, 422) == %{"error" => "The message visibility must be direct"}
	end)
	end

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	conn =
	conn
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a sensitive status", %{conn: conn} do
	conn =
	conn
	\|> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a fake status", %{conn: conn} do
	real_conn =
	conn
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
	})

	real_status = json_response(real_conn, 200)

	assert real_status
	assert Object.get_by_ap_id(real_status["uri"])

	real_status =
	real_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	fake_conn =
	conn
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
	"preview" => true
	})

	fake_status = json_response(fake_conn, 200)

	assert fake_status
	refute Object.get_by_ap_id(fake_status["uri"])

	fake_status =
	fake_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	assert real_status == fake_status
	end

	test "posting a status with OGP link preview", %{conn: conn} do
	- Pleroma.Config.put([:rich_media, :enabled], true)
	+ Config.put([:rich_media, :enabled], true)

	conn =
	conn
	\|> post("/api/v1/statuses", %{
	"status" => "https://example.com/ogp"
	})

	assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	- Pleroma.Config.put([:rich_media, :enabled], false)
	+ Config.put([:rich_media, :enabled], false)
	end

	test "posting a direct status", %{conn: conn} do
	user2 = insert(:user)
	content = "direct cofe @#{user2.nickname}"

	conn =
	conn
	\|> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
	assert activity = Activity.get_by_id(id)
	assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end
	end

	describe "posting polls" do
	test "posting a poll", %{conn: conn} do
	user = insert(:user)
	time = NaiveDateTime.utc_now()

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "Who is the #bestgrill?",
	"poll" => %{"options" => ["Rei", "Asuka", "Misato"], "expires_in" => 420}
	})

	response = json_response(conn, 200)

	assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
	title in ["Rei", "Asuka", "Misato"]
	end)

	assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
	refute response["poll"]["expred"]
	end

	test "option limit is enforced", %{conn: conn} do
	user = insert(:user)
	- limit = Pleroma.Config.get([:instance, :poll_limits, :max_options])
	+ limit = Config.get([:instance, :poll_limits, :max_options])

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "desu~",
	"poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
	})

	%{"error" => error} = json_response(conn, 422)
	assert error == "Poll can't contain more than #{limit} options"
	end

	test "option character limit is enforced", %{conn: conn} do
	user = insert(:user)
	- limit = Pleroma.Config.get([:instance, :poll_limits, :max_option_chars])
	+ limit = Config.get([:instance, :poll_limits, :max_option_chars])

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "...",
	"poll" => %{
	"options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
	"expires_in" => 1
	}
	})

	%{"error" => error} = json_response(conn, 422)
	assert error == "Poll options cannot be longer than #{limit} characters each"
	end

	test "minimal date limit is enforced", %{conn: conn} do
	user = insert(:user)
	- limit = Pleroma.Config.get([:instance, :poll_limits, :min_expiration])
	+ limit = Config.get([:instance, :poll_limits, :min_expiration])

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "imagine arbitrary limits",
	"poll" => %{
	"options" => ["this post was made by pleroma gang"],
	"expires_in" => limit - 1
	}
	})

	%{"error" => error} = json_response(conn, 422)
	assert error == "Expiration date is too soon"
	end

	test "maximum date limit is enforced", %{conn: conn} do
	user = insert(:user)
	- limit = Pleroma.Config.get([:instance, :poll_limits, :max_expiration])
	+ limit = Config.get([:instance, :poll_limits, :max_expiration])

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "imagine arbitrary limits",
	"poll" => %{
	"options" => ["this post was made by pleroma gang"],
	"expires_in" => limit + 1
	}
	})

	%{"error" => error} = json_response(conn, 422)
	assert error == "Expiration date is too far in the future"
	end
	end

	test "direct timeline", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	# Only direct should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status
	assert status["url"] != direct.data["id"]

	# User should be able to see his own direct message
	res_conn =
	build_conn()
	\|> assign(:user, user_one)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status

	# Both should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/home")

	[_s1, _s2] = json_response(res_conn, 200)

	# Test pagination
	Enum.each(1..20, fn _ ->
	{:ok, _} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})
	end)

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	statuses = json_response(res_conn, 200)
	assert length(statuses) == 20

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})

	[status] = json_response(res_conn, 200)

	assert status["url"] != direct.data["id"]
	end

	test "Conversations", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}, @#{user_three.nickname}!",
	"visibility" => "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	res_conn =
	conn
	\|> assign(:user, user_one)
	\|> get("/api/v1/conversations")

	assert response = json_response(res_conn, 200)

	assert [
	%{
	"id" => res_id,
	"accounts" => res_accounts,
	"last_status" => res_last_status,
	"unread" => unread
	}
	] = response

	account_ids = Enum.map(res_accounts, & &1["id"])
	assert length(res_accounts) == 2
	assert user_two.id in account_ids
	assert user_three.id in account_ids
	assert is_binary(res_id)
	assert unread == true
	assert res_last_status["id"] == direct.id

	# Apparently undocumented API endpoint
	res_conn =
	conn
	\|> assign(:user, user_one)
	\|> post("/api/v1/conversations/#{res_id}/read")

	assert response = json_response(res_conn, 200)
	assert length(response["accounts"]) == 2
	assert response["last_status"]["id"] == direct.id
	assert response["unread"] == false

	# (vanilla) Mastodon frontend behaviour
	res_conn =
	conn
	\|> assign(:user, user_one)
	\|> get("/api/v1/statuses/#{res_last_status["id"]}/context")

	assert %{"ancestors" => [], "descendants" => []} == json_response(res_conn, 200)
	end

	test "doesn't include DMs from blocked users", %{conn: conn} do
	blocker = insert(:user)
	blocked = insert(:user)
	user = insert(:user)
	{:ok, blocker} = User.block(blocker, blocked)

	{:ok, _blocked_direct} =
	CommonAPI.post(blocked, %{
	"status" => "Hi @#{blocker.nickname}!",
	"visibility" => "direct"
	})

	{:ok, direct} =
	CommonAPI.post(user, %{
	"status" => "Hi @#{blocker.nickname}!",
	"visibility" => "direct"
	})

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)
	assert status["id"] == direct.id
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	response = json_response(conn, 200)

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = response
	assert response["pleroma"]["chat_token"]
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted", %{conn: conn} do
	user = insert(:user, %{info: %User.Info{default_scope: "unlisted"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "apps/verify_credentials", %{conn: conn} do
	token = insert(:oauth_token)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> get("/api/v1/apps/verify_credentials")

	app = Repo.preload(token, :app).app

	expected = %{
	"name" => app.client_name,
	"website" => app.website,
	"vapid_key" => Push.vapid_config() \|> Keyword.get(:public_key)
	}

	assert expected == json_response(conn, 200)
	end

	test "user avatar can be set", %{conn: conn} do
	user = insert(:user)
	avatar_image = File.read!("test/fixtures/avatar_data_uri")

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/pleroma/accounts/update_avatar", %{img: avatar_image})

	user = refresh_record(user)

	assert %{
	"name" => _,
	"type" => _,
	"url" => [
	%{
	"href" => _,
	"mediaType" => _,
	"type" => _
	}
	]
	} = user.avatar

	assert %{"url" => _} = json_response(conn, 200)
	end

	test "user avatar can be reset", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/pleroma/accounts/update_avatar", %{img: ""})

	user = User.get_cached_by_id(user.id)

	assert user.avatar == nil

	assert %{"url" => nil} = json_response(conn, 200)
	end

	test "can set profile banner", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/pleroma/accounts/update_banner", %{"banner" => @image})

	user = refresh_record(user)
	assert user.info.banner["type"] == "Image"

	assert %{"url" => _} = json_response(conn, 200)
	end

	test "can reset profile banner", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/pleroma/accounts/update_banner", %{"banner" => ""})

	user = refresh_record(user)
	assert user.info.banner == %{}

	assert %{"url" => nil} = json_response(conn, 200)
	end

	test "background image can be set", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/pleroma/accounts/update_background", %{"img" => @image})

	user = refresh_record(user)
	assert user.info.background["type"] == "Image"
	assert %{"url" => _} = json_response(conn, 200)
	end

	test "background image can be reset", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/pleroma/accounts/update_background", %{"img" => ""})

	user = refresh_record(user)
	assert user.info.background == %{}
	assert %{"url" => nil} = json_response(conn, 200)
	end

	test "creates an oauth app", %{conn: conn} do
	user = insert(:user)
	app_attrs = build(:oauth_app)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/apps", %{
	client_name: app_attrs.client_name,
	redirect_uris: app_attrs.redirect_uris
	})

	[app] = Repo.all(App)

	expected = %{
	"name" => app.client_name,
	"website" => app.website,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret,
	"id" => app.id \|> to_string(),
	"redirect_uri" => app.redirect_uris,
	"vapid_key" => Push.vapid_config() \|> Keyword.get(:public_key)
	}

	assert expected == json_response(conn, 200)
	end

	test "get a status", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(activity.id)
	end

	describe "deleting a status" do
	test "when you created it", %{conn: conn} do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

	refute Activity.get_by_id(activity.id)
	end

	test "when you didn't create it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{"error" => _} = json_response(conn, 403)

	assert Activity.get_by_id(activity.id) == activity
	end

	test "when you're an admin or moderator", %{conn: conn} do
	activity1 = insert(:note_activity)
	activity2 = insert(:note_activity)
	admin = insert(:user, info: %{is_admin: true})
	moderator = insert(:user, info: %{is_moderator: true})

	res_conn =
	conn
	\|> assign(:user, admin)
	\|> delete("/api/v1/statuses/#{activity1.id}")

	assert %{} = json_response(res_conn, 200)

	res_conn =
	conn
	\|> assign(:user, moderator)
	\|> delete("/api/v1/statuses/#{activity2.id}")

	assert %{} = json_response(res_conn, 200)

	refute Activity.get_by_id(activity1.id)
	refute Activity.get_by_id(activity2.id)
	end
	end

	describe "filters" do
	test "creating a filter", %{conn: conn} do
	user = insert(:user)

	filter = %Pleroma.Filter{
	phrase: "knights",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

	assert response = json_response(conn, 200)
	assert response["phrase"] == filter.phrase
	assert response["context"] == filter.context
	assert response["irreversible"] == false
	assert response["id"] != nil
	assert response["id"] != ""
	end

	test "fetching a list of filters", %{conn: conn} do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	query_two = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "who",
	context: ["home"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.create(query_two)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters")
	\|> json_response(200)

	assert response ==
	render_json(
	FilterView,
	"filters.json",
	filters: [filter_two, filter_one]
	)
	end

	test "get a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters/#{filter.filter_id}")

	assert _response = json_response(conn, 200)
	end

	test "update a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, _filter} = Pleroma.Filter.create(query)

	new = %Pleroma.Filter{
	phrase: "nii",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/filters/#{query.filter_id}", %{
	phrase: new.phrase,
	context: new.context
	})

	assert response = json_response(conn, 200)
	assert response["phrase"] == new.phrase
	assert response["context"] == new.context
	end

	test "delete a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/filters/#{filter.filter_id}")

	assert response = json_response(conn, 200)
	assert response == %{}
	end
	end

	describe "lists" do
	test "creating a list", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists", %{"title" => "cuties"})

	assert %{"title" => title} = json_response(conn, 200)
	assert title == "cuties"
	end

	test "adding users to a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [other_user.follower_address]
	end

	test "removing users from a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)
	{:ok, list} = Pleroma.List.follow(list, third_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [third_user.follower_address]
	end

	test "listing users in a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "retrieving a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(list.id)
	end

	test "renaming a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})

	assert %{"title" => name} = json_response(conn, 200)
	assert name == "newname"
	end

	test "deleting a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}")

	assert %{} = json_response(conn, 200)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end

	test "list timeline", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _activity_one} = CommonAPI.post(user, %{"status" => "Marisa is cute."})
	{:ok, activity_two} = CommonAPI.post(other_user, %{"status" => "Marisa is cute."})
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_two.id)
	end

	test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity_one} = CommonAPI.post(other_user, %{"status" => "Marisa is cute."})

	{:ok, _activity_two} =
	CommonAPI.post(other_user, %{
	"status" => "Marisa is cute.",
	"visibility" => "private"
	})

	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_one.id)
	end
	end

	describe "notifications" do
	test "list of notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] = json_response(conn, 200)
	assert response == expected_response
	end

	test "getting a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/dismiss", %{"id" => notification.id})

	assert %{} = json_response(conn, 200)
	end

	test "clearing all notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/clear")

	assert %{} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	assert all = json_response(conn, 200)
	assert all == []
	end

	test "paginates notifications using min_id, since_id, max_id, and limit", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	notification1_id = Repo.get_by(Notification, activity_id: activity1.id).id \|> to_string()
	notification2_id = Repo.get_by(Notification, activity_id: activity2.id).id \|> to_string()
	notification3_id = Repo.get_by(Notification, activity_id: activity3.id).id \|> to_string()
	notification4_id = Repo.get_by(Notification, activity_id: activity4.id).id \|> to_string()

	conn =
	conn
	\|> assign(:user, user)

	# min_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result

	# since_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	# max_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
	end

	test "filters notifications using exclude_types", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, other_user)
	{:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)

	mention_notification_id =
	Repo.get_by(Notification, activity_id: mention_activity.id).id \|> to_string()

	favorite_notification_id =
	Repo.get_by(Notification, activity_id: favorite_activity.id).id \|> to_string()

	reblog_notification_id =
	Repo.get_by(Notification, activity_id: reblog_activity.id).id \|> to_string()

	follow_notification_id =
	Repo.get_by(Notification, activity_id: follow_activity.id).id \|> to_string()

	conn =
	conn
	\|> assign(:user, user)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["mention", "favourite", "reblog"]})

	assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["favourite", "reblog", "follow"]})

	assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["reblog", "follow", "mention"]})

	assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["follow", "mention", "favourite"]})

	assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)
	end

	test "destroy multiple", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
	{:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})

	notification1_id = Repo.get_by(Notification, activity_id: activity1.id).id \|> to_string()
	notification2_id = Repo.get_by(Notification, activity_id: activity2.id).id \|> to_string()
	notification3_id = Repo.get_by(Notification, activity_id: activity3.id).id \|> to_string()
	notification4_id = Repo.get_by(Notification, activity_id: activity4.id).id \|> to_string()

	conn =
	conn
	\|> assign(:user, user)

	conn_res =
	conn
	\|> get("/api/v1/notifications")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result

	conn2 =
	conn
	\|> assign(:user, other_user)

	conn_res =
	conn2
	\|> get("/api/v1/notifications")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	conn_destroy =
	conn
	\|> delete("/api/v1/notifications/destroy_multiple", %{
	"ids" => [notification1_id, notification2_id]
	})

	assert json_response(conn_destroy, 200) == %{}

	conn_res =
	conn2
	\|> get("/api/v1/notifications")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
	end

	test "doesn't see notifications after muting user with notifications", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	conn = assign(conn, :user, user)

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response(conn, 200)) == 1

	{:ok, user} = User.mute(user, user2)

	conn = assign(build_conn(), :user, user)
	conn = get(conn, "/api/v1/notifications")

	assert json_response(conn, 200) == []
	end

	test "see notifications after muting user without notifications", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	conn = assign(conn, :user, user)

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response(conn, 200)) == 1

	{:ok, user} = User.mute(user, user2, false)

	conn = assign(build_conn(), :user, user)
	conn = get(conn, "/api/v1/notifications")

	assert length(json_response(conn, 200)) == 1
	end

	test "see notifications after muting user with notifications and with_muted parameter", %{
	conn: conn
	} do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	conn = assign(conn, :user, user)

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response(conn, 200)) == 1

	{:ok, user} = User.mute(user, user2)

	conn = assign(build_conn(), :user, user)
	conn = get(conn, "/api/v1/notifications", %{"with_muted" => "true"})

	assert length(json_response(conn, 200)) == 1
	end
	end

	describe "reblogging" do
	test "reblogs and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
	"reblogged" => true
	} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "reblogged status for another user", %{conn: conn} do
	activity = insert(:note_activity)
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	CommonAPI.favorite(activity.id, user2)
	{:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
	{:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
	{:ok, _, _object} = CommonAPI.repeat(activity.id, user2)

	conn_res =
	conn
	\|> assign(:user, user3)
	\|> get("/api/v1/statuses/#{reblog_activity1.id}")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
	"reblogged" => false,
	"favourited" => false,
	"bookmarked" => false
	} = json_response(conn_res, 200)

	conn_res =
	conn
	\|> assign(:user, user2)
	\|> get("/api/v1/statuses/#{reblog_activity1.id}")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
	"reblogged" => true,
	"favourited" => true,
	"bookmarked" => true
	} = json_response(conn_res, 200)

	assert to_string(activity.id) == id
	end

	test "returns 400 error when activity is not exist", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/foo/reblog")

	assert json_response(conn, 400) == %{"error" => "Could not repeat"}
	end
	end

	describe "unreblogging" do
	test "unreblogs and returns the unreblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	{:ok, _, _} = CommonAPI.repeat(activity.id, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unreblog")

	assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 400 error when activity is not exist", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/foo/unreblog")

	assert json_response(conn, 400) == %{"error" => "Could not unrepeat"}
	end
	end

	describe "favoriting" do
	test "favs a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 400 error for a wrong id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/1/favourite")

	assert json_response(conn, 400) == %{"error" => "Could not favorite"}
	end
	end

	describe "unfavoriting" do
	test "unfavorites a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	{:ok, _, _} = CommonAPI.favorite(activity.id, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")

	assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 400 error for a wrong id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/1/unfavourite")

	assert json_response(conn, 400) == %{"error" => "Could not unfavorite"}
	end
	end

	describe "user timelines" do
	test "gets a users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, user_three} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	"status" => "Hi, @#{user_two.nickname}.",
	"visibility" => "direct"
	})

	{:ok, private_activity} =
	CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id}] = json_response(resp, 200)
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "unimplemented pinned statuses feature", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")

	assert json_response(conn, 200) == []
	end

	test "gets an users media", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	media =
	TwitterAPI.upload(file, user, "json")
	\|> Jason.decode!()

	{:ok, image_post} =
	CommonAPI.post(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)
	end

	test "gets a user's statuses without reblogs", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, _, _} = CommonAPI.repeat(post.id, user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)
	end

	test "filters user's statuses by a hashtag", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{"status" => "#hashtag"})
	{:ok, _post} = CommonAPI.post(user, %{"status" => "hashtag"})

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"tagged" => "hashtag"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)
	end
	end

	describe "user relationships" do
	test "returns the relationships for the current user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})

	assert [relationship] = json_response(conn, 200)

	assert to_string(other_user.id) == relationship["id"]
	end
	end

	describe "media upload" do
	setup do
	- upload_config = Pleroma.Config.get([Pleroma.Upload])
	- proxy_config = Pleroma.Config.get([:media_proxy])
	+ upload_config = Config.get([Pleroma.Upload])
	+ proxy_config = Config.get([:media_proxy])

	on_exit(fn ->
	- Pleroma.Config.put([Pleroma.Upload], upload_config)
	- Pleroma.Config.put([:media_proxy], proxy_config)
	+ Config.put([Pleroma.Upload], upload_config)
	+ Config.put([:media_proxy], proxy_config)
	end)

	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, user)

	image = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	[conn: conn, image: image]
	end

	test "returns uploaded image", %{conn: conn, image: image} do
	desc = "Description of the image"

	media =
	conn
	\|> post("/api/v1/media", %{"file" => image, "description" => desc})
	\|> json_response(:ok)

	assert media["type"] == "image"
	assert media["description"] == desc
	assert media["id"]

	object = Repo.get(Object, media["id"])
	assert object.data["actor"] == User.ap_id(conn.assigns[:user])
	end
	end

	describe "locked accounts" do
	test "/api/v1/follow_requests works" do
	user = insert(:user, %{info: %User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/follow_requests")

	assert [relationship] = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]
	end

	test "/api/v1/follow_requests/:id/authorize works" do
	user = insert(:user, %{info: %User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/authorize")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == true
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user, %{info: %User.Info{default_scope: "private"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "/api/v1/follow_requests/:id/reject works" do
	user = insert(:user, %{info: %User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/reject")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == false
	end
	end

	test "account fetching", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(user.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/-1")

	assert %{"error" => "Can't find user"} = json_response(conn, 404)
	end

	test "account fetching also works nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == user.id
	end

	test "mascot upload", %{conn: conn} do
	user = insert(:user)

	non_image_file = %Plug.Upload{
	content_type: "audio/mpeg",
	path: Path.absname("test/fixtures/sound.mp3"),
	filename: "sound.mp3"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/pleroma/mascot", %{"file" => non_image_file})

	assert json_response(conn, 415)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> put("/api/v1/pleroma/mascot", %{"file" => file})

	assert %{"id" => _, "type" => image} = json_response(conn, 200)
	end

	test "mascot retrieving", %{conn: conn} do
	user = insert(:user)
	# When user hasn't set a mascot, we should just get pleroma tan back
	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/pleroma/mascot")

	assert %{"url" => url} = json_response(conn, 200)
	assert url =~ "pleroma-fox-tan-smol"

	# When a user sets their mascot, we should get that back
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> put("/api/v1/pleroma/mascot", %{"file" => file})

	assert json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/pleroma/mascot")

	assert %{"url" => url, "type" => "image"} = json_response(conn, 200)
	assert url =~ "an_image"
	end

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, activity} = CommonAPI.post(following, %{"status" => "test #2hu"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2hu")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)

	# works for different capitalization too
	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2HU")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)
	end)
	end

	test "multi-hashtag timeline", %{conn: conn} do
	user = insert(:user)

	{:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
	{:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
	{:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})

	any_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})

	[status_none, status_test1, status_test] = json_response(any_test, 200)

	assert to_string(activity_test.id) == status_test["id"]
	assert to_string(activity_test1.id) == status_test1["id"]
	assert to_string(activity_none.id) == status_none["id"]

	restricted_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})

	assert [status_test1] == json_response(restricted_test, 200)

	all_test = conn \|> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})

	assert [status_none] == json_response(all_test, 200)
	end

	test "getting followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "getting followers, hide_followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_followers: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [] == json_response(conn, 200)
	end

	test "getting followers, hide_followers, same user requesting", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_followers: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response(conn, 200)
	end

	test "getting followers, pagination", %{conn: conn} do
	user = insert(:user)
	follower1 = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)
	{:ok, _} = User.follow(follower1, user)
	{:ok, _} = User.follow(follower2, user)
	{:ok, _} = User.follow(follower3, user)

	conn =
	conn
	\|> assign(:user, user)

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
	assert id3 == follower3.id
	assert id2 == follower2.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
	assert id2 == follower2.id
	assert id1 == follower1.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3.id}")

	assert [%{"id" => id2}] = json_response(res_conn, 200)
	assert id2 == follower2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{follower2.id}/
	assert link_header =~ ~r/max_id=#{follower2.id}/
	end

	test "getting following", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "getting following, hide_follows", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [] == json_response(conn, 200)
	end

	test "getting following, hide_follows, same user requesting", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response(conn, 200)
	end

	test "getting following, pagination", %{conn: conn} do
	user = insert(:user)
	following1 = insert(:user)
	following2 = insert(:user)
	following3 = insert(:user)
	{:ok, _} = User.follow(user, following1)
	{:ok, _} = User.follow(user, following2)
	{:ok, _} = User.follow(user, following3)

	conn =
	conn
	\|> assign(:user, user)

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
	assert id3 == following3.id
	assert id2 == following2.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")

	assert [%{"id" => id2}] = json_response(res_conn, 200)
	assert id2 == following2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{following2.id}/
	assert link_header =~ ~r/max_id=#{following2.id}/
	end

	test "following / unfollowing a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/follow")

	assert %{"id" => _id, "following" => true} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unfollow")

	assert %{"id" => _id, "following" => false} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follows", %{"uri" => other_user.nickname})

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "following without reblogs" do
	follower = insert(:user)
	followed = insert(:user)
	other_user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, follower)
	\|> post("/api/v1/accounts/#{followed.id}/follow?reblogs=false")

	assert %{"showing_reblogs" => false} = json_response(conn, 200)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey"})
	{:ok, reblog, _} = CommonAPI.repeat(activity.id, followed)

	conn =
	build_conn()
	\|> assign(:user, User.get_cached_by_id(follower.id))
	\|> get("/api/v1/timelines/home")

	assert [] == json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, follower)
	\|> post("/api/v1/accounts/#{followed.id}/follow?reblogs=true")

	assert %{"showing_reblogs" => true} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, User.get_cached_by_id(follower.id))
	\|> get("/api/v1/timelines/home")

	expected_activity_id = reblog.id
	assert [%{"id" => ^expected_activity_id}] = json_response(conn, 200)
	end

	test "following / unfollowing errors" do
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, user)

	# self follow
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/follow")
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# self unfollow
	user = User.get_cached_by_id(user.id)
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/unfollow")
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# self follow via uri
	user = User.get_cached_by_id(user.id)
	conn_res = post(conn, "/api/v1/follows", %{"uri" => user.nickname})
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# follow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/follow")
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# follow non existing user via uri
	conn_res = post(conn, "/api/v1/follows", %{"uri" => "doesntexist"})
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# unfollow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/unfollow")
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)
	end

	describe "mute/unmute" do
	test "with notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/mute")

	response = json_response(conn, 200)

	assert %{"id" => _id, "muting" => true, "muting_notifications" => true} = response
	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unmute")

	response = json_response(conn, 200)
	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} = response
	end

	test "without notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/mute", %{"notifications" => "false"})

	response = json_response(conn, 200)

	assert %{"id" => _id, "muting" => true, "muting_notifications" => false} = response
	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unmute")

	response = json_response(conn, 200)
	assert %{"id" => _id, "muting" => false, "muting_notifications" => false} = response
	end
	end

	test "subscribing / unsubscribing to a user", %{conn: conn} do
	user = insert(:user)
	subscription_target = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")

	assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")

	assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
	end

	test "getting a list of mutes", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.mute(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
	end

	test "getting a list of blocks", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.block(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a domain", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "getting a list of domain blocks", %{conn: conn} do
	user = insert(:user)

	{:ok, user} = User.block_domain(user, "bad.site")
	{:ok, user} = User.block_domain(user, "even.worse.site")

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/domain_blocks")

	domain_blocks = json_response(conn, 200)

	assert "bad.site" in domain_blocks
	assert "even.worse.site" in domain_blocks
	end

	test "unimplemented follow_requests, blocks, domain blocks" do
	user = insert(:user)

	["blocks", "domain_blocks", "follow_requests"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/#{endpoint}")

	assert [] = json_response(conn, 200)
	end)
	end

	test "returns the favorites of a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})

	{:ok, _, _} = CommonAPI.favorite(activity.id, user)

	first_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites")

	assert [status] = json_response(first_conn, 200)
	assert status["id"] == to_string(activity.id)

	assert [{"link", _link_header}] =
	Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)

	# Honours query params
	{:ok, second_activity} =
	CommonAPI.post(other_user, %{
	"status" =>
	"Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
	})

	{:ok, _, _} = CommonAPI.favorite(second_activity.id, user)

	last_like = status["id"]

	second_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?since_id=#{last_like}")

	assert [second_status] = json_response(second_conn, 200)
	assert second_status["id"] == to_string(second_activity.id)

	third_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?limit=0")

	assert [] = json_response(third_conn, 200)
	end

	describe "getting favorites timeline of specified user" do
	setup do
	[current_user, user] = insert_pair(:user, %{info: %{hide_favorites: false}})
	[current_user: current_user, user: user]
	end

	test "returns list of statuses favorited by specified user", %{
	conn: conn,
	current_user: current_user,
	user: user
	} do
	[activity \| _] = insert_pair(:note_activity)
	CommonAPI.favorite(activity.id, user)

	response =
	conn
	\|> assign(:user, current_user)
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	[like] = response

	assert length(response) == 1
	assert like["id"] == activity.id
	end

	test "returns favorites for specified user_id when user is not logged in", %{
	conn: conn,
	user: user
	} do
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	assert length(response) == 1
	end

	test "returns favorited DM only when user is logged in and he is one of recipients", %{
	conn: conn,
	current_user: current_user,
	user: user
	} do
	{:ok, direct} =
	CommonAPI.post(current_user, %{
	"status" => "Hi @#{user.nickname}!",
	"visibility" => "direct"
	})

	CommonAPI.favorite(direct.id, user)

	response =
	conn
	\|> assign(:user, current_user)
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	assert length(response) == 1

	anonymous_response =
	conn
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	assert Enum.empty?(anonymous_response)
	end

	test "does not return others' favorited DM when user is not one of recipients", %{
	conn: conn,
	current_user: current_user,
	user: user
	} do
	user_two = insert(:user)

	{:ok, direct} =
	CommonAPI.post(user_two, %{
	"status" => "Hi @#{user.nickname}!",
	"visibility" => "direct"
	})

	CommonAPI.favorite(direct.id, user)

	response =
	conn
	\|> assign(:user, current_user)
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "paginates favorites using since_id and max_id", %{
	conn: conn,
	current_user: current_user,
	user: user
	} do
	activities = insert_list(10, :note_activity)

	Enum.each(activities, fn activity ->
	CommonAPI.favorite(activity.id, user)
	end)

	third_activity = Enum.at(activities, 2)
	seventh_activity = Enum.at(activities, 6)

	response =
	conn
	\|> assign(:user, current_user)
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{
	since_id: third_activity.id,
	max_id: seventh_activity.id
	})
	\|> json_response(:ok)

	assert length(response) == 3
	refute third_activity in response
	refute seventh_activity in response
	end

	test "limits favorites using limit parameter", %{
	conn: conn,
	current_user: current_user,
	user: user
	} do
	7
	\|> insert_list(:note_activity)
	\|> Enum.each(fn activity ->
	CommonAPI.favorite(activity.id, user)
	end)

	response =
	conn
	\|> assign(:user, current_user)
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites", %{limit: "3"})
	\|> json_response(:ok)

	assert length(response) == 3
	end

	test "returns empty response when user does not have any favorited statuses", %{
	conn: conn,
	current_user: current_user,
	user: user
	} do
	response =
	conn
	\|> assign(:user, current_user)
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "returns 404 error when specified user is not exist", %{conn: conn} do
	conn = get(conn, "/api/v1/pleroma/accounts/test/favourites")

	assert json_response(conn, 404) == %{"error" => "Record not found"}
	end

	test "returns 403 error when user has hidden own favorites", %{
	conn: conn,
	current_user: current_user
	} do
	user = insert(:user, %{info: %{hide_favorites: true}})
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	conn =
	conn
	\|> assign(:user, current_user)
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")

	assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
	end

	test "hides favorites for new users by default", %{conn: conn, current_user: current_user} do
	user = insert(:user)
	activity = insert(:note_activity)
	CommonAPI.favorite(activity.id, user)

	conn =
	conn
	\|> assign(:user, current_user)
	\|> get("/api/v1/pleroma/accounts/#{user.id}/favourites")

	assert user.info.hide_favorites
	assert json_response(conn, 403) == %{"error" => "Can't get favorites"}
	end
	end

	test "get instance information", %{conn: conn} do
	conn = get(conn, "/api/v1/instance")
	assert result = json_response(conn, 200)

	- email = Pleroma.Config.get([:instance, :email])
	+ email = Config.get([:instance, :email])
	# Note: not checking for "max_toot_chars" since it's optional
	assert %{
	"uri" => _,
	"title" => _,
	"description" => _,
	"version" => _,
	"email" => from_config_email,
	"urls" => %{
	"streaming_api" => _
	},
	"stats" => _,
	"thumbnail" => _,
	"languages" => _,
	"registrations" => _,
	"poll_limits" => _
	} = result

	assert email == from_config_email
	end

	test "get instance stats", %{conn: conn} do
	user = insert(:user, %{local: true})

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = CommonAPI.post(user, %{"status" => "cofe"})

	# Stats should count users with missing or nil `info.deactivated` value
	user = User.get_cached_by_id(user.id)
	info_change = Changeset.change(user.info, %{deactivated: nil})

	{:ok, _user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> User.update_and_set_cache()

	- Pleroma.Stats.update_stats()
	+ Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance")

	assert result = json_response(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	- Pleroma.Stats.update_stats()
	+ Pleroma.Stats.force_update()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end

	test "put settings", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})

	assert _result = json_response(conn, 200)

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.info.settings == %{"programming" => "socks"}
	end

	describe "pinned statuses" do
	setup do
	- Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
	+ Config.put([:instance, :max_pinned_statuses], 1)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})

	[user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)

	id_str = to_string(activity.id)

	assert [%{"id" => ^id_str, "pinned" => true}] = result
	end

	test "pin status", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(200)

	assert [%{"id" => ^id_str, "pinned" => true}] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
	{:ok, dm} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{dm.id}/pin")

	assert json_response(conn, 400) == %{"error" => "Could not pin"}
	end

	test "unpin status", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "pinned" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response(200)

	assert [] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "/unpin: returns 400 error when activity is not exist", %{conn: conn, user: user} do
	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/1/unpin")

	assert json_response(conn, 400) == %{"error" => "Could not unpin"}
	end

	test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	id_str_one = to_string(activity_one.id)

	assert %{"id" => ^id_str_one, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{id_str_one}/pin")
	\|> json_response(200)

	user = refresh_record(user)

	assert %{"error" => "You have already pinned the maximum number of statuses"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity_two.id}/pin")
	\|> json_response(400)
	end
	end

	describe "cards" do
	setup do
	- Pleroma.Config.put([:rich_media, :enabled], true)
	+ Config.put([:rich_media, :enabled], true)

	on_exit(fn ->
	- Pleroma.Config.put([:rich_media, :enabled], false)
	+ Config.put([:rich_media, :enabled], false)
	end)

	user = insert(:user)
	%{user: user}
	end

	test "returns rich-media card", %{conn: conn, user: user} do
	{:ok, activity} = CommonAPI.post(user, %{"status" => "https://example.com/ogp"})

	card_data = %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"provider_name" => "example.com",
	"provider_url" => "https://example.com",
	"title" => "The Rock",
	"type" => "link",
	"url" => "https://example.com/ogp",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
	"pleroma" => %{
	"opengraph" => %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock",
	"type" => "video.movie",
	"url" => "https://example.com/ogp",
	"description" =>
	"Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
	}
	}
	}

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(200)

	assert response == card_data

	# works with private posts
	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "https://example.com/ogp", "visibility" => "direct"})

	response_two =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(200)

	assert response_two == card_data
	end

	test "replaces missing description with an empty string", %{conn: conn, user: user} do
	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "https://example.com/ogp-missing-data"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(:ok)

	assert response == %{
	"type" => "link",
	"title" => "Pleroma",
	"description" => "",
	"image" => nil,
	"provider_name" => "example.com",
	"provider_url" => "https://example.com",
	"url" => "https://example.com/ogp-missing-data",
	"pleroma" => %{
	"opengraph" => %{
	"title" => "Pleroma",
	"type" => "website",
	"url" => "https://example.com/ogp-missing-data"
	}
	}
	}
	end
	end

	test "bookmarks" do
	user = insert(:user)
	for_user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(user, %{
	"status" => "heweoo?"
	})

	{:ok, activity2} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	response1 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity1.id}/bookmark")

	assert json_response(response1, 200)["bookmarked"] == true

	response2 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity2.id}/bookmark")

	assert json_response(response2, 200)["bookmarked"] == true

	bookmarks =
	build_conn()
	\|> assign(:user, for_user)
	\|> get("/api/v1/bookmarks")

	assert [json_response(response2, 200), json_response(response1, 200)] ==
	json_response(bookmarks, 200)

	response1 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity1.id}/unbookmark")

	assert json_response(response1, 200)["bookmarked"] == false

	bookmarks =
	build_conn()
	\|> assign(:user, for_user)
	\|> get("/api/v1/bookmarks")

	assert [json_response(response2, 200)] == json_response(bookmarks, 200)
	end

	describe "conversation muting" do
	setup do
	post_user = insert(:user)
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(post_user, %{"status" => "HIE"})

	[user: user, activity: activity]
	end

	test "mute conversation", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/mute")
	\|> json_response(200)
	end

	test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/mute")

	assert json_response(conn, 400) == %{"error" => "conversation is already muted"}
	end

	test "unmute conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "muted" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unmute")
	\|> json_response(200)
	end
	end

	describe "reports" do
	setup do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})

	[reporter: reporter, target_user: target_user, activity: activity]
	end

	test "submit a basic report", %{conn: conn, reporter: reporter, target_user: target_user} do
	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"account_id" => target_user.id})
	\|> json_response(200)
	end

	test "submit a report with statuses and comment", %{
	conn: conn,
	reporter: reporter,
	target_user: target_user,
	activity: activity
	} do
	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{
	"account_id" => target_user.id,
	"status_ids" => [activity.id],
	"comment" => "bad status!",
	"forward" => "false"
	})
	\|> json_response(200)
	end

	test "account_id is required", %{
	conn: conn,
	reporter: reporter,
	activity: activity
	} do
	assert %{"error" => "Valid `account_id` required"} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"status_ids" => [activity.id]})
	\|> json_response(400)
	end

	test "comment must be up to the size specified in the config", %{
	conn: conn,
	reporter: reporter,
	target_user: target_user
	} do
	- max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
	+ max_size = Config.get([:instance, :max_report_comment_size], 1000)
	comment = String.pad_trailing("a", max_size + 1, "a")

	error = %{"error" => "Comment must be up to #{max_size} characters"}

	assert ^error =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"account_id" => target_user.id, "comment" => comment})
	\|> json_response(400)
	end

	test "returns error when account is not exist", %{
	conn: conn,
	reporter: reporter,
	activity: activity
	} do
	conn =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"status_ids" => [activity.id], "account_id" => "foo"})

	assert json_response(conn, 400) == %{"error" => "Account not found"}
	end
	end

	describe "link headers" do
	test "preserves parameters in link headers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(other_user, %{
	"status" => "hi @#{user.nickname}",
	"visibility" => "public"
	})

	{:ok, activity2} =
	CommonAPI.post(other_user, %{
	"status" => "hi @#{user.nickname}",
	"visibility" => "public"
	})

	notification1 = Repo.get_by(Notification, activity_id: activity1.id)
	notification2 = Repo.get_by(Notification, activity_id: activity2.id)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications", %{media_only: true})

	assert [link_header] = get_resp_header(conn, "link")
	assert link_header =~ ~r/media_only=true/
	assert link_header =~ ~r/min_id=#{notification2.id}/
	assert link_header =~ ~r/max_id=#{notification1.id}/
	end
	end

	test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
	# Need to set an old-style integer ID to reproduce the problem
	# (these are no longer assigned to new accounts but were preserved
	# for existing accounts during the migration to flakeIDs)
	user_one = insert(:user, %{id: 1212})
	user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})

	resp_one =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}")

	resp_two =
	conn
	\|> get("/api/v1/accounts/#{user_two.nickname}")

	resp_three =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}")

	acc_one = json_response(resp_one, 200)
	acc_two = json_response(resp_two, 200)
	acc_three = json_response(resp_three, 200)
	refute acc_one == acc_two
	assert acc_two == acc_three
	end

	describe "custom emoji" do
	test "with tags", %{conn: conn} do
	[emoji \| _body] =
	conn
	\|> get("/api/v1/custom_emojis")
	\|> json_response(200)

	assert Map.has_key?(emoji, "shortcode")
	assert Map.has_key?(emoji, "static_url")
	assert Map.has_key?(emoji, "tags")
	assert is_list(emoji["tags"])
	assert Map.has_key?(emoji, "category")
	assert Map.has_key?(emoji, "url")
	assert Map.has_key?(emoji, "visible_in_picker")
	end
	end

	describe "index/2 redirections" do
	setup %{conn: conn} do
	session_opts = [
	store: :cookie,
	key: "_test",
	signing_salt: "cooldude"
	]

	conn =
	conn
	\|> Plug.Session.call(Plug.Session.init(session_opts))
	\|> fetch_session()

	test_path = "/web/statuses/test"
	%{conn: conn, path: test_path}
	end

	test "redirects not logged-in users to the login page", %{conn: conn, path: path} do
	conn = get(conn, path)

	assert conn.status == 302
	assert redirected_to(conn) == "/web/login"
	end

	test "redirects not logged-in users to the login page on private instances", %{
	conn: conn,
	path: path
	} do
	- is_public = Pleroma.Config.get([:instance, :public])
	- Pleroma.Config.put([:instance, :public], false)
	+ is_public = Config.get([:instance, :public])
	+ Config.put([:instance, :public], false)

	conn = get(conn, path)

	assert conn.status == 302
	assert redirected_to(conn) == "/web/login"

	- Pleroma.Config.put([:instance, :public], is_public)
	+ Config.put([:instance, :public], is_public)
	end

	test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
	token = insert(:oauth_token)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> put_session(:oauth_token, token.token)
	\|> get(path)

	assert conn.status == 200
	end

	test "saves referer path to session", %{conn: conn, path: path} do
	conn = get(conn, path)
	return_to = Plug.Conn.get_session(conn, :return_to)

	assert return_to == path
	end

	test "redirects to the saved path after log in", %{conn: conn, path: path} do
	app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
	auth = insert(:oauth_authorization, app: app)

	conn =
	conn
	\|> put_session(:return_to, path)
	\|> get("/web/login", %{code: auth.token})

	assert conn.status == 302
	assert redirected_to(conn) == path
	end

	test "redirects to the getting-started page when referer is not present", %{conn: conn} do
	app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
	auth = insert(:oauth_authorization, app: app)

	conn = get(conn, "/web/login", %{code: auth.token})

	assert conn.status == 302
	assert redirected_to(conn) == "/web/getting-started"
	end
	end

	describe "scheduled activities" do
	test "creates a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
	assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(scheduled_at)
	assert [] == Repo.all(Activity)
	end

	test "creates a scheduled activity with a media attachment", %{conn: conn} do
	user = insert(:user)
	scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)],
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
	assert %{"type" => "image"} = media_attachment
	end

	test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
	%{conn: conn} do
	user = insert(:user)

	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "not scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"content" => "not scheduled"} = json_response(conn, 200)
	assert [] == Repo.all(ScheduledActivity)
	end

	test "returns error when daily user limit is exceeded", %{conn: conn} do
	user = insert(:user)

	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})

	assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
	end

	test "returns error when total user limit is exceeded", %{conn: conn} do
	user = insert(:user)

	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	tomorrow =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.hours(36), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})

	assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
	end

	test "shows scheduled activities", %{conn: conn} do
	user = insert(:user)
	scheduled_activity_id1 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id2 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id3 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id4 = insert(:scheduled_activity, user: user).id \|> to_string()

	conn =
	conn
	\|> assign(:user, user)

	# min_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&min_id=#{scheduled_activity_id1}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result

	# since_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&since_id=#{scheduled_activity_id1}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id4}, %{"id" => ^scheduled_activity_id3}] = result

	# max_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&max_id=#{scheduled_activity_id4}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
	end

	test "shows a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{"id" => scheduled_activity_id} = json_response(res_conn, 200)
	assert scheduled_activity_id == scheduled_activity.id \|> to_string()

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/scheduled_statuses/404")

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end

	test "updates a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	new_scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/scheduled_statuses/#{scheduled_activity.id}", %{
	scheduled_at: new_scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} = json_response(res_conn, 200)
	assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(new_scheduled_at)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/scheduled_statuses/404", %{scheduled_at: new_scheduled_at})

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end

	test "deletes a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{} = json_response(res_conn, 200)
	assert nil == Repo.get(ScheduledActivity, scheduled_activity.id)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end
	end

	test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, replied_to} = CommonAPI.post(user1, %{"status" => "cofe"})

	# Reply to status from another user
	conn1 =
	conn
	\|> assign(:user, user2)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)

	activity = Activity.get_by_id_with_object(id)

	assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id

	# Reblog from the third user
	conn2 =
	conn
	\|> assign(:user, user3)
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
	json_response(conn2, 200)

	assert to_string(activity.id) == id

	# Getting third user status
	conn3 =
	conn
	\|> assign(:user, user3)
	\|> get("api/v1/timelines/home")

	[reblogged_activity] = json_response(conn3, 200)

	assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id

	replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
	assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
	end

	describe "create account by app" do
	test "Account registration via Application", %{conn: conn} do
	conn =
	conn
	\|> post("/api/v1/apps", %{
	client_name: "client_name",
	redirect_uris: "urn:ietf:wg:oauth:2.0:oob",
	scopes: "read, write, follow"
	})

	%{
	"client_id" => client_id,
	"client_secret" => client_secret,
	"id" => _,
	"name" => "client_name",
	"redirect_uri" => "urn:ietf:wg:oauth:2.0:oob",
	"vapid_key" => _,
	"website" => nil
	} = json_response(conn, 200)

	conn =
	conn
	\|> post("/oauth/token", %{
	grant_type: "client_credentials",
	client_id: client_id,
	client_secret: client_secret
	})

	assert %{"access_token" => token, "refresh_token" => refresh, "scope" => scope} =
	json_response(conn, 200)

	assert token
	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	assert refresh
	assert scope == "read write follow"

	conn =
	build_conn()
	\|> put_req_header("authorization", "Bearer " <> token)
	\|> post("/api/v1/accounts", %{
	username: "lain",
	email: "lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	%{
	"access_token" => token,
	"created_at" => _created_at,
	"scope" => _scope,
	"token_type" => "Bearer"
	} = json_response(conn, 200)

	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	token_from_db = Repo.preload(token_from_db, :user)
	assert token_from_db.user

	assert token_from_db.user.info.confirmation_pending
	end

	test "rate limit", %{conn: conn} do
	app_token = insert(:oauth_token, user: nil)

	conn =
	put_req_header(conn, "authorization", "Bearer " <> app_token.token)
	\|> Map.put(:remote_ip, {15, 15, 15, 15})

	for i <- 1..5 do
	conn =
	conn
	\|> post("/api/v1/accounts", %{
	username: "#{i}lain",
	email: "#{i}lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	%{
	"access_token" => token,
	"created_at" => _created_at,
	"scope" => _scope,
	"token_type" => "Bearer"
	} = json_response(conn, 200)

	token_from_db = Repo.get_by(Token, token: token)
	assert token_from_db
	token_from_db = Repo.preload(token_from_db, :user)
	assert token_from_db.user

	assert token_from_db.user.info.confirmation_pending
	end

	conn =
	conn
	\|> post("/api/v1/accounts", %{
	username: "6lain",
	email: "6lain@example.org",
	password: "PlzDontHackLain",
	agreement: true
	})

	assert json_response(conn, :too_many_requests) == %{"error" => "Throttled"}
	end
	end

	describe "GET /api/v1/polls/:id" do
	test "returns poll entity for object id", %{conn: conn} do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Pleroma does",
	"poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20}
	})

	object = Object.normalize(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/polls/#{object.id}")

	response = json_response(conn, 200)
	id = to_string(object.id)
	assert %{"id" => ^id, "expired" => false, "multiple" => false} = response
	end

	test "does not expose polls for private statuses", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Pleroma does",
	"poll" => %{"options" => ["what Mastodon't", "n't what Mastodoes"], "expires_in" => 20},
	"visibility" => "private"
	})

	object = Object.normalize(activity)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/polls/#{object.id}")

	assert json_response(conn, 404)
	end
	end

	describe "POST /api/v1/polls/:id/votes" do
	test "votes are added to the poll", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "A very delicious sandwich",
	"poll" => %{
	"options" => ["Lettuce", "Grilled Bacon", "Tomato"],
	"expires_in" => 20,
	"multiple" => true
	}
	})

	object = Object.normalize(activity)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1, 2]})

	assert json_response(conn, 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", %{conn: conn} do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Am I cute?",
	"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
	})

	object = Object.normalize(activity)

	assert conn
	\|> assign(:user, user)
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [1]})
	\|> json_response(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
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "The glass is",
	"poll" => %{"options" => ["half empty", "half full"], "expires_in" => 20}
	})

	object = Object.normalize(activity)

	assert conn
	\|> assign(:user, other_user)
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0, 1]})
	\|> json_response(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
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Am I cute?",
	"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20}
	})

	object = Object.normalize(activity)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [2]})

	assert json_response(conn, 422) == %{"error" => "Invalid indices"}
	end

	test "returns 404 error when object is not exist", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/polls/1/votes", %{"choices" => [0]})

	assert json_response(conn, 404) == %{"error" => "Record not found"}
	end

	test "returns 404 when poll is private and not available for user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "Am I cute?",
	"poll" => %{"options" => ["Yes", "No"], "expires_in" => 20},
	"visibility" => "private"
	})

	object = Object.normalize(activity)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> post("/api/v1/polls/#{object.id}/votes", %{"choices" => [0]})

	assert json_response(conn, 404) == %{"error" => "Record not found"}
	end
	end

	describe "GET /api/v1/statuses/:id/favourited_by" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "test"})

	conn =
	build_conn()
	\|> assign(:user, user)

	[conn: conn, activity: activity]
	end

	test "returns users who have favorited the status", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response(:ok)

	[%{"id" => id}] = response

	assert id == other_user.id
	end

	test "returns empty array when status has not been favorited yet", %{
	conn: conn,
	activity: activity
	} do
	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have favorited the status but are blocked", %{
	conn: %{assigns: %{user: user}} = conn,
	activity: activity
	} do
	other_user = insert(:user)
	{:ok, user} = User.block(user, other_user)

	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "does not fail on an unauthenticated request", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	response =
	conn
	\|> assign(:user, nil)
	\|> get("/api/v1/statuses/#{activity.id}/favourited_by")
	\|> json_response(:ok)

	[%{"id" => id}] = response
	assert id == other_user.id
	end
	end

	describe "GET /api/v1/statuses/:id/reblogged_by" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "test"})

	conn =
	build_conn()
	\|> assign(:user, user)

	[conn: conn, activity: activity]
	end

	test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response(:ok)

	[%{"id" => id}] = response

	assert id == other_user.id
	end

	test "returns empty array when status has not been reblogged yet", %{
	conn: conn,
	activity: activity
	} do
	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "does not return users who have reblogged the status but are blocked", %{
	conn: %{assigns: %{user: user}} = conn,
	activity: activity
	} do
	other_user = insert(:user)
	{:ok, user} = User.block(user, other_user)

	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response(:ok)

	assert Enum.empty?(response)
	end

	test "does not fail on an unauthenticated request", %{conn: conn, activity: activity} do
	other_user = insert(:user)
	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

	response =
	conn
	\|> assign(:user, nil)
	\|> get("/api/v1/statuses/#{activity.id}/reblogged_by")
	\|> json_response(:ok)

	[%{"id" => id}] = response
	assert id == other_user.id
	end
	end

	describe "POST /auth/password, with valid parameters" do
	setup %{conn: conn} do
	user = insert(:user)
	conn = post(conn, "/auth/password?email=#{user.email}")
	%{conn: conn, user: user}
	end

	test "it returns 204", %{conn: conn} do
	assert json_response(conn, :no_content)
	end

	test "it creates a PasswordResetToken record for user", %{user: user} do
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)
	assert token_record
	end

	test "it sends an email to user", %{user: user} do
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)

	email = Pleroma.Emails.UserEmail.password_reset_email(user, token_record.token)
	- notify_email = Pleroma.Config.get([:instance, :notify_email])
	- instance_name = Pleroma.Config.get([:instance, :name])
	+ notify_email = Config.get([:instance, :notify_email])
	+ instance_name = Config.get([:instance, :name])

	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end
	end

	describe "POST /auth/password, with invalid parameters" do
	setup do
	user = insert(:user)
	{:ok, user: user}
	end

	test "it returns 404 when user is not found", %{conn: conn, user: user} do
	conn = post(conn, "/auth/password?email=nonexisting_#{user.email}")
	assert conn.status == 404
	assert conn.resp_body == ""
	end

	test "it returns 400 when user is not local", %{conn: conn, user: user} do
	{:ok, user} = Repo.update(Changeset.change(user, local: false))
	conn = post(conn, "/auth/password?email=#{user.email}")
	assert conn.status == 400
	assert conn.resp_body == ""
	end
	end

	describe "POST /api/v1/pleroma/accounts/confirmation_resend" do
	setup do
	- setting = Pleroma.Config.get([:instance, :account_activation_required])
	+ setting = Config.get([:instance, :account_activation_required])

	unless setting do
	- Pleroma.Config.put([:instance, :account_activation_required], true)
	- on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	+ Config.put([:instance, :account_activation_required], true)
	+ on_exit(fn -> Config.put([:instance, :account_activation_required], setting) end)
	end

	user = insert(:user)
	info_change = User.Info.confirmation_changeset(user.info, need_confirmation: true)

	{:ok, user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> Repo.update()

	assert user.info.confirmation_pending

	[user: user]
	end

	test "resend account confirmation email", %{conn: conn, user: user} do
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/accounts/confirmation_resend?email=#{user.email}")
	\|> json_response(:no_content)

	email = Pleroma.Emails.UserEmail.account_confirmation_email(user)
	- notify_email = Pleroma.Config.get([:instance, :notify_email])
	- instance_name = Pleroma.Config.get([:instance, :name])
	+ notify_email = Config.get([:instance, :notify_email])
	+ instance_name = Config.get([:instance, :name])

	assert_email_sent(
	from: {instance_name, notify_email},
	to: {user.name, user.email},
	html_body: email.html_body
	)
	end
	end
	+
	+ describe "GET /api/v1/suggestions" do
	+ setup do
	+ user = insert(:user)
	+ other_user = insert(:user)
	+ config = Config.get(:suggestions)
	+ on_exit(fn -> Config.put(:suggestions, config) end)
	+
	+ host = Config.get([Pleroma.Web.Endpoint, :url, :host])
	+ url500 = "http://test500?#{host}&#{user.nickname}"
	+ url200 = "http://test200?#{host}&#{user.nickname}"
	+
	+ mock(fn
	+ %{method: :get, url: ^url500} ->
	+ %Tesla.Env{status: 500, body: "bad request"}
	+
	+ %{method: :get, url: ^url200} ->
	+ %Tesla.Env{
	+ status: 200,
	+ body:
	+ ~s([{"acct":"yj455","avatar":"https://social.heldscal.la/avatar/201.jpeg","avatar_static":"https://social.heldscal.la/avatar/s/201.jpeg"}, {"acct":"#{
	+ other_user.ap_id
	+ }","avatar":"https://social.heldscal.la/avatar/202.jpeg","avatar_static":"https://social.heldscal.la/avatar/s/202.jpeg"}])
	+ }
	+ end)
	+
	+ [user: user, other_user: other_user]
	+ end
	+
	+ test "returns empty result when suggestions disabled", %{conn: conn, user: user} do
	+ Config.put([:suggestions, :enabled], false)
	+
	+ res =
	+ conn
	+ \|> assign(:user, user)
	+ \|> get("/api/v1/suggestions")
	+ \|> json_response(200)
	+
	+ assert res == []
	+ end
	+
	+ test "returns error", %{conn: conn, user: user} do
	+ Config.put([:suggestions, :enabled], true)
	+ Config.put([:suggestions, :third_party_engine], "http://test500?{{host}}&{{user}}")
	+
	+ res =
	+ conn
	+ \|> assign(:user, user)
	+ \|> get("/api/v1/suggestions")
	+ \|> json_response(500)
	+
	+ assert res == "Something went wrong"
	+ end
	+
	+ test "returns suggestions", %{conn: conn, user: user, other_user: other_user} do
	+ Config.put([:suggestions, :enabled], true)
	+ Config.put([:suggestions, :third_party_engine], "http://test200?{{host}}&{{user}}")
	+
	+ res =
	+ conn
	+ \|> assign(:user, user)
	+ \|> get("/api/v1/suggestions")
	+ \|> json_response(200)
	+
	+ assert res == [
	+ %{
	+ "acct" => "yj455",
	+ "avatar" => "https://social.heldscal.la/avatar/201.jpeg",
	+ "avatar_static" => "https://social.heldscal.la/avatar/s/201.jpeg",
	+ "id" => 0
	+ },
	+ %{
	+ "acct" => other_user.ap_id,
	+ "avatar" => "https://social.heldscal.la/avatar/202.jpeg",
	+ "avatar_static" => "https://social.heldscal.la/avatar/s/202.jpeg",
	+ "id" => other_user.id
	+ }
	+ ]
	+ end
	+ end
	end
	diff --git a/test/web/mastodon_api/mastodon_api_test.exs b/test/web/mastodon_api/mastodon_api_test.exs
	new file mode 100644
	index 000000000..b4c0427c9
	--- /dev/null
	+++ b/test/web/mastodon_api/mastodon_api_test.exs
	@@ -0,0 +1,103 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.MastodonAPI.MastodonAPITest do
	+ use Pleroma.Web.ConnCase
	+
	+ alias Pleroma.Notification
	+ alias Pleroma.ScheduledActivity
	+ alias Pleroma.User
	+ alias Pleroma.Web.MastodonAPI.MastodonAPI
	+ alias Pleroma.Web.TwitterAPI.TwitterAPI
	+
	+ import Pleroma.Factory
	+
	+ describe "follow/3" do
	+ test "returns error when user deactivated" do
	+ follower = insert(:user)
	+ user = insert(:user, local: true, info: %{deactivated: true})
	+ {:error, error} = MastodonAPI.follow(follower, user)
	+ assert error == "Could not follow user: You are deactivated."
	+ end
	+
	+ test "following for user" do
	+ follower = insert(:user)
	+ user = insert(:user)
	+ {:ok, follower} = MastodonAPI.follow(follower, user)
	+ assert User.following?(follower, user)
	+ end
	+
	+ test "returns ok if user already followed" do
	+ follower = insert(:user)
	+ user = insert(:user)
	+ {:ok, follower} = User.follow(follower, user)
	+ {:ok, follower} = MastodonAPI.follow(follower, refresh_record(user))
	+ assert User.following?(follower, user)
	+ end
	+ end
	+
	+ describe "get_followers/2" do
	+ test "returns user followers" do
	+ follower1_user = insert(:user)
	+ follower2_user = insert(:user)
	+ user = insert(:user)
	+ {:ok, _follower1_user} = User.follow(follower1_user, user)
	+ {:ok, follower2_user} = User.follow(follower2_user, user)
	+
	+ assert MastodonAPI.get_followers(user, %{"limit" => 1}) == [follower2_user]
	+ end
	+ end
	+
	+ describe "get_friends/2" do
	+ test "returns user friends" do
	+ user = insert(:user)
	+ followed_one = insert(:user)
	+ followed_two = insert(:user)
	+ followed_three = insert(:user)
	+
	+ {:ok, user} = User.follow(user, followed_one)
	+ {:ok, user} = User.follow(user, followed_two)
	+ {:ok, user} = User.follow(user, followed_three)
	+ res = MastodonAPI.get_friends(user)
	+
	+ assert length(res) == 3
	+ assert Enum.member?(res, refresh_record(followed_three))
	+ assert Enum.member?(res, refresh_record(followed_two))
	+ assert Enum.member?(res, refresh_record(followed_one))
	+ end
	+ end
	+
	+ describe "get_notifications/2" do
	+ test "returns notifications for user" do
	+ user = insert(:user)
	+ subscriber = insert(:user)
	+
	+ User.subscribe(subscriber, user)
	+
	+ {:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
	+ {:ok, status1} = TwitterAPI.create_status(user, %{"status" => "Magi"})
	+ {:ok, [notification]} = Notification.create_notifications(status)
	+ {:ok, [notification1]} = Notification.create_notifications(status1)
	+ res = MastodonAPI.get_notifications(subscriber)
	+
	+ assert Enum.member?(Enum.map(res, & &1.id), notification.id)
	+ assert Enum.member?(Enum.map(res, & &1.id), notification1.id)
	+ end
	+ end
	+
	+ describe "get_scheduled_activities/2" do
	+ test "returns user scheduled activities" do
	+ user = insert(:user)
	+
	+ today =
	+ NaiveDateTime.utc_now()
	+ \|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	+ \|> NaiveDateTime.to_iso8601()
	+
	+ attrs = %{params: %{}, scheduled_at: today}
	+ {:ok, schedule} = ScheduledActivity.create(user, attrs)
	+ assert MastodonAPI.get_scheduled_activities(user) == [schedule]
	+ end
	+ end
	+end
	diff --git a/test/web/node_info_test.exs b/test/web/node_info_test.exs
	index d7f848bfa..f6147c286 100644
	--- a/test/web/node_info_test.exs
	+++ b/test/web/node_info_test.exs
	@@ -1,129 +1,137 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.NodeInfoTest do
	use Pleroma.Web.ConnCase

	import Pleroma.Factory

	test "GET /.well-known/nodeinfo", %{conn: conn} do
	links =
	conn
	\|> get("/.well-known/nodeinfo")
	\|> json_response(200)
	\|> Map.fetch!("links")

	Enum.each(links, fn link ->
	href = Map.fetch!(link, "href")

	conn
	\|> get(href)
	\|> json_response(200)
	end)
	end

	test "nodeinfo shows staff accounts", %{conn: conn} do
	moderator = insert(:user, %{local: true, info: %{is_moderator: true}})
	admin = insert(:user, %{local: true, info: %{is_admin: true}})

	conn =
	conn
	\|> get("/nodeinfo/2.1.json")

	assert result = json_response(conn, 200)

	assert moderator.ap_id in result["metadata"]["staffAccounts"]
	assert admin.ap_id in result["metadata"]["staffAccounts"]
	end

	test "nodeinfo shows restricted nicknames", %{conn: conn} do
	conn =
	conn
	\|> get("/nodeinfo/2.1.json")

	assert result = json_response(conn, 200)

	assert Pleroma.Config.get([Pleroma.User, :restricted_nicknames]) ==
	result["metadata"]["restrictedNicknames"]
	end

	test "returns software.repository field in nodeinfo 2.1", %{conn: conn} do
	conn
	\|> get("/.well-known/nodeinfo")
	\|> json_response(200)

	conn =
	conn
	\|> get("/nodeinfo/2.1.json")

	assert result = json_response(conn, 200)
	assert Pleroma.Application.repository() == result["software"]["repository"]
	end

	test "it returns the safe_dm_mentions feature if enabled", %{conn: conn} do
	option = Pleroma.Config.get([:instance, :safe_dm_mentions])
	Pleroma.Config.put([:instance, :safe_dm_mentions], true)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert "safe_dm_mentions" in response["metadata"]["features"]

	Pleroma.Config.put([:instance, :safe_dm_mentions], false)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	refute "safe_dm_mentions" in response["metadata"]["features"]

	Pleroma.Config.put([:instance, :safe_dm_mentions], option)
	end

	test "it shows MRF transparency data if enabled", %{conn: conn} do
	+ config = Pleroma.Config.get([:instance, :rewrite_policy])
	+ Pleroma.Config.put([:instance, :rewrite_policy], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])
	+
	option = Pleroma.Config.get([:instance, :mrf_transparency])
	Pleroma.Config.put([:instance, :mrf_transparency], true)

	simple_config = %{"reject" => ["example.com"]}
	Pleroma.Config.put(:mrf_simple, simple_config)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert response["metadata"]["federation"]["mrf_simple"] == simple_config

	+ Pleroma.Config.put([:instance, :rewrite_policy], config)
	Pleroma.Config.put([:instance, :mrf_transparency], option)
	Pleroma.Config.put(:mrf_simple, %{})
	end

	test "it performs exclusions from MRF transparency data if configured", %{conn: conn} do
	+ config = Pleroma.Config.get([:instance, :rewrite_policy])
	+ Pleroma.Config.put([:instance, :rewrite_policy], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])
	+
	option = Pleroma.Config.get([:instance, :mrf_transparency])
	Pleroma.Config.put([:instance, :mrf_transparency], true)

	exclusions = Pleroma.Config.get([:instance, :mrf_transparency_exclusions])
	Pleroma.Config.put([:instance, :mrf_transparency_exclusions], ["other.site"])

	simple_config = %{"reject" => ["example.com", "other.site"]}
	expected_config = %{"reject" => ["example.com"]}

	Pleroma.Config.put(:mrf_simple, simple_config)

	response =
	conn
	\|> get("/nodeinfo/2.1.json")
	\|> json_response(:ok)

	assert response["metadata"]["federation"]["mrf_simple"] == expected_config
	assert response["metadata"]["federation"]["exclusions"] == true

	+ Pleroma.Config.put([:instance, :rewrite_policy], config)
	Pleroma.Config.put([:instance, :mrf_transparency], option)
	Pleroma.Config.put([:instance, :mrf_transparency_exclusions], exclusions)
	Pleroma.Config.put(:mrf_simple, %{})
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 10, 7:05 PM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1785408
Default Alt Text: (619 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions