No OneTemporary
Actions

Authored By

Unknown

Size

550 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/.gitignore b/.gitignore
	index 04c61ede7..774893b35 100644
	--- a/.gitignore
	+++ b/.gitignore
	@@ -1,37 +1,40 @@
	# App artifacts
	/_build
	/db
	/deps
	/*.ez
	/uploads
	/test/uploads
	/.elixir_ls
	/test/fixtures/test_tmp.txt
	/test/fixtures/image_tmp.jpg
	/test/tmp/
	/doc
	/instance

	# Prevent committing custom emojis
	/priv/static/emoji/custom/*

	# Generated on crash by the VM
	erl_crash.dump

	# Files matching config/*.secret.exs pattern contain sensitive
	# data and you should not commit them into version control.
	#
	# Alternatively, you may comment the line below and commit the
	# secrets files as long as you replace their contents by environment
	# variables.
	/config/*.secret.exs
	/config/generated_config.exs

	# Database setup file, some may forget to delete it
	/config/setup_db.psql

	.DS_Store
	.env

	# Editor config
	/.vscode/
	+
	+# Prevent committing docs files
	+/priv/static/doc/*
	diff --git a/config/config.exs b/config/config.exs
	index 92a6ed296..c9584fc04 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,412 +1,436 @@
	# 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]

	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"]
	+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`
	+ Finmoji: "/finmoji/128px/*-128.png",
	+ Custom: ["/emoji/.png", "/emoji/custom/.png"]
	+ ]

	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

	# 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,
	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",
	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,
	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"
	],
	finmoji_enabled: true,
	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,
	two_factor_authentication: [
	# digits 6 or 8
	digits: 6,
	period: 30,
	backup_codes: [
	number: 5,
	code_length: 16
	]
	]

	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
	]

	# Deprecated, will be gone in 1.0
	config :pleroma, :fe,
	theme: "pleroma-dark",
	logo: "/static/logo.png",
	logo_mask: true,
	logo_margin: "0.1em",
	background: "/static/aurora_borealis.jpg",
	redirect_root_no_login: "/main/all",
	redirect_root_login: "/main/friends",
	show_instance_panel: true,
	scope_options_enabled: false,
	formatting_options_enabled: false,
	collapse_message_with_subject: false,
	hide_post_stats: false,
	hide_user_stats: false,
	scope_copy: true,
	subject_line_behavior: "email",
	always_show_subject_input: true

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

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

	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: [], 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",
	"dev",
	"friend-requests",
	"inbox",
	"internal",
	"main",
	"media",
	"nodeinfo",
	"notice",
	"oauth",
	"objects",
	"ostatus_subscribe",
	"pleroma",
	"proxy",
	"push",
	"registration",
	"relay",
	"settings",
	"status",
	"tag",
	"user-search",
	"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

	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"

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

	# 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/dev.exs b/config/dev.exs
	index f77bb9976..a7eb4b644 100644
	--- a/config/dev.exs
	+++ b/config/dev.exs
	@@ -1,62 +1,61 @@
	use Mix.Config

	# For development, we disable any cache and enable
	# debugging and code reloading.
	#
	# The watchers configuration can be used to run external
	# watchers to your application. For example, we use it
	# with brunch.io to recompile .js and .css sources.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [
	port: 4000,
	protocol_options: [max_request_line_length: 8192, max_header_value_length: 8192]
	],
	protocol: "http",
	- secure_cookie_flag: false,
	debug_errors: true,
	code_reloader: true,
	check_origin: false,
	watchers: [],
	secure_cookie_flag: false

	config :pleroma, Pleroma.Mailer, adapter: Swoosh.Adapters.Local

	# ## SSL Support
	#
	# In order to use HTTPS in development, a self-signed
	# certificate can be generated by running the following
	# command from your terminal:
	#
	# openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 -subj "/C=US/ST=Denial/L=Springfield/O=Dis/CN=www.example.com" -keyout priv/server.key -out priv/server.pem
	#
	# The `http:` config above can be replaced with:
	#
	# https: [port: 4000, keyfile: "priv/server.key", certfile: "priv/server.pem"],
	#
	# If desired, both `http:` and `https:` keys can be
	# configured to run both http and https servers on
	# different ports.

	# Do not include metadata nor timestamps in development logs
	config :logger, :console, format: "[$level] $message\n"

	# Set a higher stacktrace during development. Avoid configuring such
	# in production as building large stacktraces may be expensive.
	config :phoenix, :stacktrace_depth, 20

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_dev",
	hostname: "localhost",
	pool_size: 10

	if File.exists?("./config/dev.secret.exs") do
	import_config "dev.secret.exs"
	else
	IO.puts(
	"!!! RUNNING IN LOCALHOST DEV MODE! !!!\nFEDERATION WON'T WORK UNTIL YOU CONFIGURE A dev.secret.exs"
	)
	end
	diff --git a/config/emoji.txt b/config/emoji.txt
	index 7afacb09f..79246f239 100644
	--- a/config/emoji.txt
	+++ b/config/emoji.txt
	@@ -1,31 +1,30 @@
	-firefox, /emoji/Firefox.gif
	-blank, /emoji/blank.png
	+firefox, /emoji/Firefox.gif, Gif,Fun
	+blank, /emoji/blank.png, Fun
	f_00b, /emoji/f_00b.png
	f_00b11b, /emoji/f_00b11b.png
	f_00b33b, /emoji/f_00b33b.png
	f_00h, /emoji/f_00h.png
	f_00t, /emoji/f_00t.png
	f_01b, /emoji/f_01b.png
	f_03b, /emoji/f_03b.png
	f_10b, /emoji/f_10b.png
	f_11b, /emoji/f_11b.png
	f_11b00b, /emoji/f_11b00b.png
	f_11b22b, /emoji/f_11b22b.png
	f_11h, /emoji/f_11h.png
	f_11t, /emoji/f_11t.png
	f_12b, /emoji/f_12b.png
	f_21b, /emoji/f_21b.png
	f_22b, /emoji/f_22b.png
	f_22b11b, /emoji/f_22b11b.png
	f_22b33b, /emoji/f_22b33b.png
	f_22h, /emoji/f_22h.png
	f_22t, /emoji/f_22t.png
	f_23b, /emoji/f_23b.png
	f_30b, /emoji/f_30b.png
	f_32b, /emoji/f_32b.png
	f_33b, /emoji/f_33b.png
	f_33b00b, /emoji/f_33b00b.png
	f_33b22b, /emoji/f_33b22b.png
	f_33h, /emoji/f_33h.png
	f_33t, /emoji/f_33t.png
	-
	diff --git a/docs/api/pleroma_api.md b/docs/api/pleroma_api.md
	index 2eb74de67..7e7bc2ba2 100644
	--- a/docs/api/pleroma_api.md
	+++ b/docs/api/pleroma_api.md
	@@ -1,156 +1,156 @@
	# Pleroma API

	Requests that require it can be authenticated with [an OAuth token](https://tools.ietf.org/html/rfc6749), the `_pleroma_key` cookie, or [HTTP Basic Authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization).

	Request parameters can be passed via [query strings](https://en.wikipedia.org/wiki/Query_string) or as [form data](https://www.w3.org/TR/html401/interact/forms.html). Files must be uploaded as `multipart/form-data`.

	## `/api/pleroma/emoji`
	### Lists the custom emoji on that server.
	* Method: `GET`
	* Authentication: not required
	* Params: none
	* Response: JSON
	-* Example response: `{"kalsarikannit_f":"/finmoji/128px/kalsarikannit_f-128.png","perkele":"/finmoji/128px/perkele-128.png","blobdab":"/emoji/blobdab.png","happiness":"/finmoji/128px/happiness-128.png"}`
	+* Example response: `[{"kalsarikannit_f":{"tags":["Finmoji"],"image_url":"/finmoji/128px/kalsarikannit_f-128.png"}},{"perkele":{"tags":["Finmoji"],"image_url":"/finmoji/128px/perkele-128.png"}},{"blobdab":{"tags":["SomeTag"],"image_url":"/emoji/blobdab.png"}},"happiness":{"tags":["Finmoji"],"image_url":"/finmoji/128px/happiness-128.png"}}]`
	* Note: Same data as Mastodon API’s `/api/v1/custom_emojis` but in a different format

	## `/api/pleroma/follow_import`
	### Imports your follows, for example from a Mastodon CSV file.
	* Method: `POST`
	* Authentication: required
	* Params:
	* `list`: STRING or FILE containing a whitespace-separated list of accounts to follow
	* Response: HTTP 200 on success, 500 on error
	* Note: Users that can't be followed are silently skipped.

	## `/api/pleroma/captcha`
	### Get a new captcha
	* Method: `GET`
	* Authentication: not required
	* Params: none
	* Response: Provider specific JSON, the only guaranteed parameter is `type`
	* Example response: `{"type": "kocaptcha", "token": "whatever", "url": "https://captcha.kotobank.ch/endpoint"}`

	## `/api/pleroma/delete_account`
	### Delete an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{"status": "success"}` if the deletion was successful, `{"error": "[error message]"}` otherwise
	* Example response: `{"error": "Invalid password."}`

	## `/api/account/register`
	### Register a new user
	* Method `POST`
	* Authentication: not required
	* Params:
	* `nickname`
	* `fullname`
	* `bio`
	* `email`
	* `password`
	* `confirm`
	* `captcha_solution`: optional, contains provider-specific captcha solution,
	* `captcha_token`: optional, contains provider-specific captcha token
	* `token`: invite token required when the registerations aren't public.
	* Response: JSON. Returns a user object on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```
	{
	"background_image": null,
	"cover_photo": "https://pleroma.soykaf.com/images/banner.png",
	"created_at": "Tue Dec 18 16:55:56 +0000 2018",
	"default_scope": "public",
	"description": "blushy-crushy fediverse idol + pleroma dev\nlet's be friends \nぷれろまの生徒会長。謎の外人。日本語OK. \n公主病.",
	"description_html": "blushy-crushy fediverse idol + pleroma dev.<br />let's be friends <br />ぷれろまの生徒会長。謎の外人。日本語OK. <br />公主病.",
	"favourites_count": 0,
	"fields": [],
	"followers_count": 0,
	"following": false,
	"follows_you": false,
	"friends_count": 0,
	"id": 6,
	"is_local": true,
	"locked": false,
	"name": "lain",
	"name_html": "lain",
	"no_rich_text": false,
	"pleroma": {
	"tags": []
	},
	"profile_image_url": "https://pleroma.soykaf.com/images/avi.png",
	"profile_image_url_https": "https://pleroma.soykaf.com/images/avi.png",
	"profile_image_url_original": "https://pleroma.soykaf.com/images/avi.png",
	"profile_image_url_profile_size": "https://pleroma.soykaf.com/images/avi.png",
	"rights": {
	"delete_others_notice": false
	},
	"screen_name": "lain",
	"statuses_count": 0,
	"statusnet_blocking": false,
	"statusnet_profile_url": "https://pleroma.soykaf.com/users/lain"
	}

	## `/api/pleroma/2fa/provisioning_uri`
	#### Generates secret key and uri to generate qrcode
	* method: `GET`
	* Authentication: required
	* Params: none
	* Response: JSON. Returns `{"status": "success", "provisioning_uri": [uri]})}`, `{"error": "[error message]"}` otherwise
	* Example response: `{"status": "success", "provisioning_uri": "otpauth://totp/test@example.com?digits=8&issuer=Plerome-42&period=60&secret=test-secrcet"}`


	## `/api/pleroma/2fa/enable`
	#### Enables 2FA support for user account.
	* method: `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* `otp_token`: token from TOTP App
	* Response: JSON. Returns `{"status": "success"}` if the enable was successful, `{"error": "[error message]"}` otherwise
	* Example response: `{"error": "Invalid password."}`

	## `/api/pleroma/2fa/disable`
	#### Disables 2FA for user account.
	* method: `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{"status": "success"}` if the disable was successful, `{"error": "[error message]"}` otherwise
	* Example response: `{"error": "Invalid password."}`

	## `/api/pleroma/2fa/backup_codes`
	#### Generstes backup codes 2FA for user account.
	* method: `GET`
	* Authentication: required
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{"status": "success", "codes": codes}`, `{"error": "[error message]"}` otherwise


	```

	## `/api/pleroma/admin/`…
	See [Admin-API](Admin-API.md)

	## `/api/v1/pleroma/flavour/:flavour`
	* Method `POST`
	* Authentication: required
	* Response: JSON string. Returns the user flavour or the default one on success, otherwise returns `{"error": "error_msg"}`
	* Example response: "glitch"
	* Note: This is intended to be used only by mastofe

	## `/api/v1/pleroma/flavour`
	* Method `GET`
	* Authentication: required
	* Response: JSON string. Returns the user flavour or the default one.
	* Example response: "glitch"
	* Note: This is intended to be used only by mastofe

	## `/api/pleroma/notifications/read`
	### Mark a single notification as read
	* Method `POST`
	* Authentication: required
	* Params:
	* `id`: notifications's id
	* Response: JSON. Returns `{"status": "success"}` if the reading was successful, otherwise returns `{"error": "error_msg"}`
	diff --git a/docs/config.md b/docs/config.md
	index ba0759e87..b5ea58746 100644
	--- a/docs/config.md
	+++ b/docs/config.md
	@@ -1,421 +1,483 @@
	# 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.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:

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

	An example for SMTP adapter:

	```exs
	config :pleroma, Pleroma.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
	* `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)
	* `finmoji_enabled`: Whenether to enable the finmojis in the custom emojis.
	* `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`)

	## :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:
	```
	config :logger,
	backends: [{ExSyslogger, :ex_syslogger}]

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

	Another example, keeping console output and adding the pid to syslog output:
	```
	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:
	```
	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:

	`config :pleroma, :frontend_configurations, pleroma_fe: %{redirectRootNoLogin: "/main/all", ...}`

	These settings need to be complete, they will override the defaults. See `priv/static/static/config.json` for the available keys.

	## :fe
	__THIS IS DEPRECATED__

	If you are using this method, please change it to the `frontend_configurations` method. Please set this option to false in your config like this: `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, …)

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

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

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


	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"`.

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

	```exs
	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:

	```exs
	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.Mailer`](#pleroma-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 availible:
	* Pleroma.Web.Metadata.Providers.OpenGraph
	* Pleroma.Web.Metadata.Providers.TwitterCard
	* `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:

	```exs
	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"

	-## Pleroma.Web.Auth.Authenticator
	+## :auth

	-* `Pleroma.Web.Auth.PleromaAuthenticator`: default database authenticator
	-* `Pleroma.Web.Auth.LDAPAuthenticator`: LDAP authentication
	+Authentication / authorization settings.

	-## Pleroma.ScheduledActivity
	+* `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.

	-* `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
	+# 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.
	+
	+* 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:
	+
	+```
	+# 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: []]}
	+ ]
	+```
	diff --git a/docs/config/custom_emoji.md b/docs/config/custom_emoji.md
	index e833d2080..419a7d0e2 100644
	--- a/docs/config/custom_emoji.md
	+++ b/docs/config/custom_emoji.md
	@@ -1,18 +1,53 @@
	# Custom Emoji

	To add custom emoji:
	* Add the image file(s) to `priv/static/emoji/custom`
	* In case of conflicts: add the desired shortcode with the path to `config/custom_emoji.txt`, comma-separated and one per line
	* Force recompilation (``mix clean && mix compile``)

	Example:

	image files (in `/priv/static/emoji/custom`): `happy.png` and `sad.png`

	content of `config/custom_emoji.txt`:
	```
	-happy, /emoji/custom/happy.png
	-sad, /emoji/custom/sad.png
	+happy, /emoji/custom/happy.png, Tag1,Tag2
	+sad, /emoji/custom/sad.png, Tag1
	+foo, /emoji/custom/foo.png
	```

	The files should be PNG (APNG is okay with `.png` for `image/png` Content-type) and under 50kb for compatibility with mastodon.
	+
	+## Emoji tags (groups)
	+
	+Default tags are set in `config.exs`.
	+```elixir
	+config :pleroma, :emoji,
	+ shortcode_globs: ["/emoji/custom/*/.png"],
	+ groups: [
	+ Finmoji: "/finmoji/128px/*-128.png",
	+ Custom: ["/emoji/.png", "/emoji/custom/.png"]
	+ ]
	+```
	+
	+Order of the `groups` matters, so to override default tags just put your group on top of the list. E.g:
	+```elixir
	+config :pleroma, :emoji,
	+ shortcode_globs: ["/emoji/custom/*/.png"],
	+ groups: [
	+ "Finmoji special": "/finmoji/128px/a_trusted_friend-128.png", # special file
	+ "Cirno": "/emoji/custom/cirno*.png", # png files in /emoji/custom/ which start with `cirno`
	+ "Special group": "/emoji/custom/special_folder/*.png", # png files in /emoji/custom/special_folder/
	+ "Another group": "/emoji/custom/special_folder/*/.png", # png files in /emoji/custom/special_folder/ subfolders
	+ Finmoji: "/finmoji/128px/*-128.png",
	+ Custom: ["/emoji/.png", "/emoji/custom/.png"]
	+ ]
	+```
	+
	+Priority of tags assigns in emoji.txt and custom.txt:
	+
	+`tag in file > special group setting in config.exs > default setting in config.exs`
	+
	+Priority for globs:
	+
	+`special group setting in config.exs > default setting in config.exs`
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index f0cb7d9a8..eeb415084 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,186 +1,186 @@
	# 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.Stats, []),
	- worker(Pleroma.Web.Push, []),
	- worker(Task, [&Pleroma.Web.Federator.init/0], restart: :temporary)
	+ 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,
	%{}
	)

	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/config.ex b/lib/pleroma/config.ex
	index 21507cd38..189faa15f 100644
	--- a/lib/pleroma/config.ex
	+++ b/lib/pleroma/config.ex
	@@ -1,60 +1,64 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config do
	defmodule Error do
	defexception [:message]
	end

	def get(key), do: get(key, nil)

	def get([key], default), do: get(key, default)

	def get([parent_key \| keys], default) do
	Application.get_env(:pleroma, parent_key)
	\|> get_in(keys) \|\| default
	end

	def get(key, default) do
	Application.get_env(:pleroma, key, default)
	end

	def get!(key) do
	value = get(key, nil)

	if value == nil do
	raise(Error, message: "Missing configuration value: #{inspect(key)}")
	else
	value
	end
	end

	def put([key], value), do: put(key, value)

	def put([parent_key \| keys], value) do
	parent =
	Application.get_env(:pleroma, parent_key)
	\|> put_in(keys, value)

	Application.put_env(:pleroma, parent_key, parent)
	end

	def put(key, value) do
	Application.put_env(:pleroma, key, value)
	end

	def delete([key]), do: delete(key)

	def delete([parent_key \| keys]) do
	{_, parent} =
	Application.get_env(:pleroma, parent_key)
	\|> get_and_update_in(keys, fn _ -> :pop end)

	Application.put_env(:pleroma, parent_key, parent)
	end

	def delete(key) do
	Application.delete_env(:pleroma, key)
	end
	+
	+ def oauth_consumer_strategies, do: get([:auth, :oauth_consumer_strategies], [])
	+
	+ def oauth_consumer_enabled?, do: oauth_consumer_strategies() != []
	end
	diff --git a/lib/pleroma/emoji.ex b/lib/pleroma/emoji.ex
	index f3f08cd9d..87c7f2cec 100644
	--- a/lib/pleroma/emoji.ex
	+++ b/lib/pleroma/emoji.ex
	@@ -1,198 +1,245 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	* the built-in Finmojis (if enabled in configuration),
	* the files: `config/emoji.txt` and `config/custom_emoji.txt`
	- * glob paths
	+ * glob paths, nested folder is used as tag name for grouping e.g. priv/static/emoji/custom/nested_folder

	This GenServer stores in an ETS table the list of the loaded emojis, and also allows to reload the list at runtime.
	"""
	use GenServer
	+
	+ @type pattern :: Regex.t() \| module() \| String.t()
	+ @type patterns :: pattern() \| [pattern()]
	+ @type group_patterns :: keyword(patterns())
	+
	@ets __MODULE__.Ets
	@ets_options [:ordered_set, :protected, :named_table, {:read_concurrency, true}]
	+ @groups Application.get_env(:pleroma, :emoji)[:groups]

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

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

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

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

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

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

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

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

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

	defp load do
	+ finmoji_enabled = Keyword.get(Application.get_env(:pleroma, :instance), :finmoji_enabled)
	+ shortcode_globs = Application.get_env(:pleroma, :emoji)[:shortcode_globs] \|\| []
	+
	emojis =
	- (load_finmoji(Keyword.get(Application.get_env(:pleroma, :instance), :finmoji_enabled)) ++
	+ (load_finmoji(finmoji_enabled) ++
	load_from_file("config/emoji.txt") ++
	load_from_file("config/custom_emoji.txt") ++
	- load_from_globs(
	- Keyword.get(Application.get_env(:pleroma, :emoji, []), :shortcode_globs, [])
	- ))
	+ load_from_globs(shortcode_globs))
	\|> Enum.reject(fn value -> value == nil end)

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

	@finmoji [
	"a_trusted_friend",
	"alandislands",
	"association",
	"auroraborealis",
	"baby_in_a_box",
	"bear",
	"black_gold",
	"christmasparty",
	"crosscountryskiing",
	"cupofcoffee",
	"education",
	"fashionista_finns",
	"finnishlove",
	"flag",
	"forest",
	"four_seasons_of_bbq",
	"girlpower",
	"handshake",
	"happiness",
	"headbanger",
	"icebreaker",
	"iceman",
	"joulutorttu",
	"kaamos",
	"kalsarikannit_f",
	"kalsarikannit_m",
	"karjalanpiirakka",
	"kicksled",
	"kokko",
	"lavatanssit",
	"losthopes_f",
	"losthopes_m",
	"mattinykanen",
	"meanwhileinfinland",
	"moominmamma",
	"nordicfamily",
	"out_of_office",
	"peacemaker",
	"perkele",
	"pesapallo",
	"polarbear",
	"pusa_hispida_saimensis",
	"reindeer",
	"sami",
	"sauna_f",
	"sauna_m",
	"sauna_whisk",
	"sisu",
	"stuck",
	"suomimainittu",
	"superfood",
	"swan",
	"the_cap",
	"the_conductor",
	"the_king",
	"the_voice",
	"theoriginalsanta",
	"tomoffinland",
	"torillatavataan",
	"unbreakable",
	"waiting",
	"white_nights",
	"woollysocks"
	]
	+
	defp load_finmoji(true) do
	Enum.map(@finmoji, fn finmoji ->
	- {finmoji, "/finmoji/128px/#{finmoji}-128.png"}
	+ file_name = "/finmoji/128px/#{finmoji}-128.png"
	+ group = match_extra(@groups, file_name)
	+ {finmoji, file_name, to_string(group)}
	end)
	end

	defp load_finmoji(_), do: []

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

	defp load_from_file_stream(stream) do
	stream
	\|> Stream.map(&String.trim/1)
	\|> Stream.map(fn line ->
	case String.split(line, ~r/,\s*/) do
	- [name, file] -> {name, file}
	- _ -> nil
	+ [name, file, tags] ->
	+ {name, file, tags}
	+
	+ [name, file] ->
	+ {name, file, to_string(match_extra(@groups, file))}
	+
	+ _ ->
	+ nil
	end
	end)
	\|> Enum.to_list()
	end

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

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

	Enum.map(paths, fn path ->
	+ tag = match_extra(@groups, Path.join("/", Path.relative_to(path, static_path)))
	shortcode = Path.basename(path, Path.extname(path))
	external_path = Path.join("/", Path.relative_to(path, static_path))
	- {shortcode, external_path}
	+ {shortcode, external_path, to_string(tag)}
	+ end)
	+ end
	+
	+ @doc """
	+ Finds a matching group for the given emoji filename
	+ """
	+ @spec match_extra(group_patterns(), String.t()) :: atom() \| nil
	+ def match_extra(group_patterns, filename) do
	+ match_group_patterns(group_patterns, fn pattern ->
	+ case pattern do
	+ %Regex{} = regex -> Regex.match?(regex, filename)
	+ string when is_binary(string) -> filename == string
	+ end
	+ end)
	+ end
	+
	+ defp match_group_patterns(group_patterns, matcher) do
	+ Enum.find_value(group_patterns, fn {group, patterns} ->
	+ patterns =
	+ patterns
	+ \|> List.wrap()
	+ \|> Enum.map(fn pattern ->
	+ if String.contains?(pattern, "*") do
	+ ~r(#{String.replace(pattern, "", ".")})
	+ else
	+ pattern
	+ end
	+ end)
	+
	+ Enum.any?(patterns, matcher) && group
	end)
	end
	end
	diff --git a/lib/pleroma/formatter.ex b/lib/pleroma/formatter.ex
	index e3625383b..8ea9dbd38 100644
	--- a/lib/pleroma/formatter.ex
	+++ b/lib/pleroma/formatter.ex
	@@ -1,149 +1,149 @@
	# 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>.)/
	@markdown_characters_regex ~r/(`\|\*\|_\|{\|}\|[\|]\|$\|$\|#\|\+\|-\|\.\|!)/
	@link_regex ~r{((?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~%:/?#[\]@!\$&'\\+,;=.]+)\|[0-9a-z+\-\.]+:[0-9a-z$-_.+!'(),]+}ui
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength

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

	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) \|> maybe_escape(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

	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, file}, text ->
	- emoji = HTML.strip_tags(emoji)
	- file = HTML.strip_tags(file)
	+ 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 height='32px' width='32px' 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

	def get_emoji(text) when is_binary(text) do
	- Enum.filter(Emoji.get_all(), fn {emoji, _} -> String.contains?(text, ":#{emoji}:") end)
	+ Enum.filter(Emoji.get_all(), fn {emoji, _, _} -> String.contains?(text, ":#{emoji}:") end)
	end

	def get_emoji(_), 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)

	defp maybe_escape(str, %{mentions_escape: true}) do
	String.replace(str, @markdown_characters_regex, "\\\\\\1")
	end

	defp maybe_escape(str, _), do: str
	end
	diff --git a/lib/pleroma/registration.ex b/lib/pleroma/registration.ex
	new file mode 100644
	index 000000000..21fd1fc3f
	--- /dev/null
	+++ b/lib/pleroma/registration.ex
	@@ -0,0 +1,57 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Registration do
	+ use Ecto.Schema
	+
	+ import Ecto.Changeset
	+
	+ alias Pleroma.Registration
	+ alias Pleroma.Repo
	+ alias Pleroma.User
	+
	+ @primary_key {:id, Pleroma.FlakeId, autogenerate: true}
	+
	+ schema "registrations" do
	+ belongs_to(:user, User, type: Pleroma.FlakeId)
	+ field(:provider, :string)
	+ field(:uid, :string)
	+ field(:info, :map, default: %{})
	+
	+ timestamps()
	+ end
	+
	+ def nickname(registration, default \\ nil),
	+ do: Map.get(registration.info, "nickname", default)
	+
	+ def email(registration, default \\ nil),
	+ do: Map.get(registration.info, "email", default)
	+
	+ def name(registration, default \\ nil),
	+ do: Map.get(registration.info, "name", default)
	+
	+ def description(registration, default \\ nil),
	+ do: Map.get(registration.info, "description", default)
	+
	+ def changeset(registration, params \\ %{}) do
	+ registration
	+ \|> cast(params, [:user_id, :provider, :uid, :info])
	+ \|> validate_required([:provider, :uid])
	+ \|> foreign_key_constraint(:user_id)
	+ \|> unique_constraint(:uid, name: :registrations_provider_uid_index)
	+ end
	+
	+ def bind_to_user(registration, user) do
	+ registration
	+ \|> changeset(%{user_id: (user && user.id) \|\| nil})
	+ \|> Repo.update()
	+ end
	+
	+ def get_by_provider_uid(provider, uid) do
	+ Repo.get_by(Registration,
	+ provider: to_string(provider),
	+ uid: to_string(uid)
	+ )
	+ end
	+end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index feee6d6cd..361000e65 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1433 +1,1441 @@
	# 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.Formatter
	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.Auth.TOTP
	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(:bookmarks, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:otp_enabled, :boolean, default: false)
	field(:otp_secret, :string)
	field(:otp_backup_codes, {:array, :string}, default: [])

	has_many(:notifications, Notification)
	+ has_many(:registrations, Registration)
	embeds_one(:info, Pleroma.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
	oneself = if user.local, do: 1, else: 0

	%{
	following_count: length(user.following) - oneself,
	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 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])
	\|> 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
	confirmation_status =
	if opts[:confirmed] \|\| !Pleroma.Config.get([:instance, :account_activation_required]) do
	:confirmed
	else
	:unconfirmed
	end

	info_change = User.Info.confirmation_changeset(%User.Info{}, confirmation_status)

	changeset =
	struct
	\|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
	- \|> validate_required([: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([Pleroma.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 =
	from(u in User,
	where: u.local == true,
	where: u.nickname in ^candidates
	)
	\|> 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, _} <- Pleroma.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.UserEmail.account_confirmation_email()
	\|> Pleroma.Mailer.deliver_async()
	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 follow_import(%User{} = follower, followed_identifiers)
	when is_list(followed_identifiers) do
	Enum.map(
	followed_identifiers,
	fn followed_identifier ->
	with %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 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_by_nickname(nickname)
	end

	def set_cache(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 _ -> get_or_fetch_by_nickname(nickname) 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

	@spec get_by_nickname(String.t()) :: User.t() \| nil
	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname) \|\|
	if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
	Repo.get_by(User, nickname: local_nickname(nickname))
	end
	end

	+ def get_by_email(email), do: Repo.get_by(User, email: email)
	+
	def get_by_nickname_or_email(nickname_or_email) do
	- case user = Repo.get_by(User, nickname: nickname_or_email) do
	- %User{} -> user
	- nil -> Repo.get_by(User, email: nickname_or_email)
	- end
	+ 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
	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
	{:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
	end

	user
	else
	_e -> nil
	end
	end
	end

	@doc "Fetch some posts when the user has just been federated with"
	def fetch_initial_posts(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
	)
	end

	def get_followers_query(%User{id: id, follower_address: follower_address}, nil) do
	from(
	u in User,
	where: fragment("? <@ ?", ^[follower_address], u.following),
	where: u.id != ^id
	)
	end

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

	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

	def get_friends_query(%User{id: id, following: following}, nil) do
	from(
	u in User,
	where: u.follower_address in ^following,
	where: u.id != ^id
	)
	end

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

	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

	def get_follow_requests_query(%User{} = user) 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,
	^user.ap_id
	)
	)
	end

	def get_follow_requests(%User{} = user) do
	users =
	user
	\|> User.get_follow_requests_query()
	\|> 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)

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

	update_and_set_cache(cng)
	end

	def update_follower_count(%User{} = user) do
	follower_count_query =
	User
	\|> where([u], ^user.follower_address in u.following)
	\|> where([u], u.id != ^user.id)
	\|> 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 get_users_from_set_query(ap_ids, false) do
	from(
	u in User,
	where: u.ap_id in ^ap_ids
	)
	end

	def get_users_from_set_query(ap_ids, true) do
	query = get_users_from_set_query(ap_ids, false)

	from(
	u in query,
	where: u.local == true
	)
	end

	def get_users_from_set(ap_ids, local_only \\ true) do
	get_users_from_set_query(ap_ids, local_only)
	\|> Repo.all()
	end

	def get_recipients_from_activity(%Activity{recipients: to}) do
	query =
	from(
	u in User,
	where: u.ap_id in ^to,
	or_where: fragment("? && ?", u.following, ^to)
	)

	query = from(u in query, where: u.local == true)

	Repo.all(query)
	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
	)
	)
	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)
	)
	end

	def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
	Enum.map(
	blocked_identifiers,
	fn blocked_identifier ->
	with %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

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

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

	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, User.get_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 muted_users(user),
	do: Repo.all(from(u in User, where: u.ap_id in ^user.info.mutes))

	def blocked_users(user),
	do: Repo.all(from(u in User, where: u.ap_id in ^user.info.blocks))

	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 maybe_local_user_query(query, local) do
	if local, do: local_user_query(query), else: query
	end

	def local_user_query(query \\ User) do
	from(
	u in query,
	where: u.local == true,
	where: not is_nil(u.nickname)
	)
	end

	def maybe_external_user_query(query, external) do
	if external, do: external_user_query(query), else: query
	end

	def external_user_query(query \\ User) do
	from(
	u in query,
	where: u.local == false,
	where: not is_nil(u.nickname)
	)
	end

	def maybe_active_user_query(query, active) do
	if active, do: active_user_query(query), else: query
	end

	def active_user_query(query \\ User) do
	from(
	u in query,
	where: fragment("not (?->'deactivated' @> 'true')", u.info),
	where: not is_nil(u.nickname)
	)
	end

	def maybe_deactivated_user_query(query, deactivated) do
	if deactivated, do: deactivated_user_query(query), else: query
	end

	def deactivated_user_query(query \\ User) do
	from(
	u in query,
	where: fragment("(?->'deactivated' @> 'true')", u.info),
	where: not is_nil(u.nickname)
	)
	end

	def active_local_user_query do
	from(
	u in local_user_query(),
	where: fragment("not (?->'deactivated' @> 'true')", u.info)
	)
	end

	def moderator_user_query do
	from(
	u in User,
	where: u.local == true,
	where: fragment("?->'is_moderator' @> 'true'", u.info)
	)
	end

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

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

	update_and_set_cache(cng)
	end

	def 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

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	Activity
	\|> where(actor: ^ap_id)
	\|> Activity.with_preloaded_object()
	\|> Repo.all()
	\|> Enum.each(fn
	%{data: %{"type" => "Create"}} = activity ->
	activity \|> Object.normalize() \|> ActivityPub.delete()

	# TODO: Do something with likes, follows, repeats.
	_ ->
	"Doing nothing"
	end)

	{:ok, user}
	end

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

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

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

	if !is_nil(user) and !User.needs_update?(user) do
	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])

	user = fetch_by_ap_id(ap_id)

	if should_fetch_initial do
	with %User{} = user do
	{:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
	end
	end

	user
	end
	end

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

	if user = get_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 %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 =
	data
	\|> Map.put(:name, blank?(data[:name]) \|\| data[:nickname])

	cs = User.remote_user_creation(data)

	Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
	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()) :: User.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_by_id(a.id),
	%User{} = b <- User.get_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_by_id(a.id),
	%User{} = b <- User.get_by_id(b.id) do
	{:ok, a, b}
	else
	_e ->
	:error
	end
	end

	def parse_bio(bio, user \\ %User{info: %{source_data: %{}}})
	def parse_bio(nil, _user), do: ""
	def parse_bio(bio, _user) when bio == "", do: bio

	def parse_bio(bio, user) do
	emoji =
	(user.info.source_data["tag"] \|\| [])
	\|> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
	\|> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
	{String.trim(name, ":"), url}
	end)

	# 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)
	\|> Formatter.emojify(emoji)
	end

	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(User.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(User.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

	def bookmark(%User{} = user, status_id) do
	bookmarks = Enum.uniq(user.bookmarks ++ [status_id])
	update_bookmarks(user, bookmarks)
	end

	def unbookmark(%User{} = user, status_id) do
	bookmarks = Enum.uniq(user.bookmarks -- [status_id])
	update_bookmarks(user, bookmarks)
	end

	def update_bookmarks(%User{} = user, bookmarks) do
	user
	\|> change(%{bookmarks: bookmarks})
	\|> update_and_set_cache
	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

	def all_superusers do
	from(
	u in User,
	where: u.local == true,
	where: fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
	)
	\|> Repo.all()
	end

	defp paginate(query, page, page_size) do
	from(u in query,
	limit: ^page_size,
	offset: ^((page - 1) * page_size)
	)
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	target.ap_id not in user.info.muted_reblogs
	end

	def mfa_required?(%User{otp_enabled: true} = _), do: true
	def mfa_required?(_), do: false

	@doc "Enable 2fa for account."
	@spec enable_2fa(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def enable_2fa(%User{} = user) do
	user
	\|> cast(%{otp_enabled: true}, [:otp_enabled])
	\|> Repo.update()
	end

	@doc "Disable 2fa for account."
	@spec disable_2fa(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def disable_2fa(%User{} = user) do
	user
	\|> cast(
	%{otp_enabled: false, otp_backup_codes: [], otp_secret: nil},
	[:otp_enabled, :otp_backup_codes, :otp_secret]
	)
	\|> Repo.update()
	end

	@doc "Generates and set secret key for 2fa"
	@spec set_2fa_secret(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_2fa_secret(%User{} = user) do
	user
	\|> cast(%{otp_secret: TOTP.generate_secret()}, [:otp_secret])
	\|> Repo.update()
	end

	@doc "Updates backup codes for 2fa"
	@spec update_2fa_backup_codes(User.t(), list(String.t())) ::
	{:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def update_2fa_backup_codes(%User{} = user, hashed_codes) do
	user
	\|> cast(%{otp_backup_codes: hashed_codes}, [:otp_backup_codes])
	\|> Repo.update()
	end

	@doc "clears backup code of 2fa"
	@spec invalidate_2fa_backup_code(User.t(), String.t()) ::
	{:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def invalidate_2fa_backup_code(%User{otp_backup_codes: hash_codes} = user, hash_code) do
	user
	\|> cast(%{otp_backup_codes: hash_codes -- [hash_code]}, [:otp_backup_codes])
	\|> Repo.update()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index f733ae7e1..593ae3188 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1053 +1,1043 @@
	# 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.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	import Ecto.Query

	require Logger

	def get_actor(%{"actor" => actor}) when is_binary(actor) do
	actor
	end

	def get_actor(%{"actor" => actor}) when is_list(actor) do
	if is_binary(Enum.at(actor, 0)) do
	Enum.at(actor, 0)
	else
	Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
	\|> Map.get("id")
	end
	end

	def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
	id
	end

	def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
	get_actor(%{"actor" => actor})
	end

	@doc """
	Checks that an imported AP object's actor matches the domain it came from.
	"""
	def contain_origin(_id, %{"actor" => nil}), do: :error

	def contain_origin(id, %{"actor" => _actor} = params) do
	id_uri = URI.parse(id)
	actor_uri = URI.parse(get_actor(params))

	if id_uri.host == actor_uri.host do
	:ok
	else
	:error
	end
	end

	def contain_origin_from_id(_id, %{"id" => nil}), do: :error

	def contain_origin_from_id(id, %{"id" => other_id} = _params) do
	id_uri = URI.parse(id)
	other_uri = URI.parse(other_id)

	if id_uri.host == other_uri.host do
	:ok
	else
	:error
	end
	end

	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object) do
	object
	\|> fix_actor
	\|> fix_url
	\|> fix_attachments
	\|> fix_context
	\|> fix_in_reply_to
	\|> fix_emoji
	\|> fix_tag
	\|> fix_content_map
	\|> fix_likes
	\|> fix_addressing
	end

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

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

	true ->
	map
	end
	end

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

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

	final_cc =
	(cc ++ explicit_cc)
	\|> Enum.uniq()

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

	def fix_explicit_addressing(object, _explicit_mentions), do: object

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

	def fix_explicit_addressing(object) do
	explicit_mentions =
	object
	\|> Utils.determine_explicit_mentions()

	explicit_mentions = explicit_mentions ++ ["https://www.w3.org/ns/activitystreams#Public"]

	object
	\|> fix_explicit_addressing(explicit_mentions)
	end

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

	if followers_collection not in recipients do
	cond do
	"https://www.w3.org/ns/activitystreams#Public" in cc ->
	to = to ++ [followers_collection]
	Map.put(object, "to", to)

	"https://www.w3.org/ns/activitystreams#Public" in to ->
	cc = cc ++ [followers_collection]
	Map.put(object, "cc", cc)

	true ->
	object
	end
	else
	object
	end
	end

	def fix_implicit_addressing(object, _), do: object

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

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

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

	# Check for standardisation
	# This is what Peertube does
	# curl -H 'Accept: application/activity+json' $likes \| jq .totalItems
	# Prismo returns only an integer (count) as "likes"
	def fix_likes(%{"likes" => likes} = object) when not is_map(likes) do
	object
	\|> Map.put("likes", [])
	\|> Map.put("like_count", 0)
	end

	def fix_likes(object) do
	object
	end

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object)
	when not is_nil(in_reply_to) do
	in_reply_to_id =
	cond do
	is_bitstring(in_reply_to) ->
	in_reply_to

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

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

	# Maybe I should output an error too?
	true ->
	""
	end

	case fetch_obj_helper(in_reply_to_id) do
	{:ok, replied_object} ->
	with %Activity{} = activity <-
	Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] \|\| in_reply_to_id)
	\|> Map.put("inReplyToStatusId", activity.id)
	\|> Map.put("conversation", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])
	else
	e ->
	Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
	object
	end

	e ->
	Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
	object
	end
	end

	def fix_in_reply_to(object), do: object

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

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

	def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	attachments =
	attachment
	\|> Enum.map(fn data ->
	media_type = data["mediaType"] \|\| data["mimeType"]
	href = data["url"] \|\| data["href"]

	url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]

	data
	\|> Map.put("mediaType", media_type)
	\|> Map.put("url", url)
	end)

	object
	\|> Map.put("attachment", attachments)
	end

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

	def fix_attachments(object), do: object

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

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

	link_element =
	url
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["mimeType"] == "text/html" end)
	\|> Enum.at(0)

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

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

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

	object
	\|> Map.put("url", url_string)
	end

	def fix_url(object), do: object

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

	emoji =
	emoji
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

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

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

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

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

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

	def fix_emoji(object), do: object

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

	combined = tag ++ tags

	object
	\|> Map.put("tag", combined)
	end

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

	object
	\|> Map.put("tag", combined)
	end

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

	def fix_tag(object), do: object

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

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

	def fix_content_map(object), do: object

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

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

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

	_ ->
	{:error, nil}
	end
	end

	# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
	# with nil ID.
	def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data) do
	with context <- data["context"] \|\| Utils.generate_context_id(),
	content <- data["content"] \|\| "",
	%User{} = actor <- User.get_cached_by_ap_id(actor),

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

	# Remove the reported user from the object list.
	statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
	params = %{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content,
	additional: %{
	"cc" => [account.ap_id]
	}
	}

	ActivityPub.flag(params)
	end
	end

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

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

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

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

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

	ActivityPub.create(params)
	else
	%Activity{} = activity -> {:ok, activity}
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	%User{} = follower <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
	if not User.locked?(followed) do
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: data,
	local: true
	})

	User.follow(follower, followed)
	end

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data
	) do
	with actor <- get_actor(data),
	%User{} = followed <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, activity} <-
	ActivityPub.accept(%{
	to: follow_activity.data["to"],
	type: "Accept",
	actor: followed,
	object: follow_activity.data["id"],
	local: false
	}) do
	if not User.following?(follower, followed) do
	{:ok, _follower} = User.follow(follower, followed)
	end

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data
	) do
	with actor <- get_actor(data),
	%User{} = followed <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, activity} <-
	ActivityPub.reject(%{
	to: follow_activity.data["to"],
	type: "Reject",
	actor: followed,
	object: follow_activity.data["id"],
	local: false
	}) do
	User.unfollow(follower, followed)

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data
	) do
	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	{:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data
	) do
	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	public <- Visibility.is_public?(data),
	{:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

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

	banner = new_user_data[:info]["banner"]
	locked = new_user_data[:info]["locked"] \|\| false

	update_data =
	new_user_data
	\|> Map.take([:name, :bio, :avatar])
	\|> Map.put(:info, %{"banner" => banner, "locked" => locked})

	actor
	\|> User.upgrade_changeset(update_data)
	\|> User.update_and_set_cache()

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

	# TODO: We presently assume that any actor on the same origin domain as the object being
	# deleted has the rights to delete that object. A better way to validate whether or not
	# the object should be deleted is to refetch the object URI, which should return either
	# an error or a tombstone. This would allow us to verify that a deletion actually took
	# place.
	def handle_incoming(
	%{"type" => "Delete", "object" => object_id, "actor" => _actor, "id" => _id} = data
	) do
	object_id = Utils.get_ap_id(object_id)

	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	:ok <- contain_origin(actor.ap_id, object.data),
	{:ok, activity} <- ActivityPub.delete(object, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Announce", "object" => object_id},
	"actor" => _actor,
	"id" => id
	} = data
	) do
	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	{:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

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

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Block", "object" => blocked},
	"actor" => blocker,
	"id" => id
	} = _data
	) do
	with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
	%User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
	%User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
	{:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
	User.unblock(blocker, blocked)
	{:ok, activity}
	else
	_e -> :error
	end
	end

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

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Like", "object" => object_id},
	"actor" => _actor,
	"id" => id
	} = data
	) do
	with actor <- get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	{:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	{:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(_), do: :error

	def fetch_obj_helper(id) when is_bitstring(id), do: ActivityPub.fetch_object_from_id(id)
	def fetch_obj_helper(obj) when is_map(obj), do: ActivityPub.fetch_object_from_id(obj["id"])

	def get_obj_helper(id) do
	if object = Object.normalize(id), do: {:ok, object}, else: nil
	end

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

	def set_reply_to_uri(obj), do: obj

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

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

	def prepare_outgoing(%{"type" => "Create", "object" => object} = data) do
	object =
	object
	\|> prepare_object

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

	{:ok, data}
	end

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

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

	{:ok, data}
	end
	end

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

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

	{:ok, data}
	end
	end

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

	{:ok, data}
	end

	def maybe_fix_object_url(data) do
	if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
	case fetch_obj_helper(data["object"]) do
	{:ok, relative_object} ->
	if relative_object.data["external_url"] do
	_data =
	data
	\|> Map.put("object", relative_object.data["external_url"])
	else
	data
	end

	e ->
	Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
	data
	end
	else
	data
	end
	end

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

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

	object
	\|> Map.put("tag", tags)
	end

	def add_mention_tags(object) do
	mentions =
	object
	\|> Utils.get_notified_from_object()
	\|> Enum.map(fn user ->
	%{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
	end)

	tags = object["tag"] \|\| []

	object
	\|> Map.put("tag", tags ++ mentions)
	end

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

	out =
	emoji
	\|> Enum.map(fn {name, url} ->
	%{
	"icon" => %{"url" => url, "type" => "Image"},
	"name" => ":" <> name <> ":",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z",
	"id" => url
	}
	end)

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

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

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

	def add_attributed_to(object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]

	object
	\|> Map.put("attributedTo", attributed_to)
	end

	def add_likes(%{"id" => id, "like_count" => likes} = object) do
	likes = %{
	"id" => "#{id}/likes",
	"first" => "#{id}/likes?page=1",
	"type" => "OrderedCollection",
	"totalItems" => likes
	}

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

	def add_likes(object) do
	object
	end

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

	object
	\|> Map.put("attachment", attachments)
	end

	defp strip_internal_fields(object) do
	object
	\|> Map.drop([
	"like_count",
	"announcements",
	"announcement_count",
	"emoji",
	"context_id",
	"deleted_activity_id"
	])
	end

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

	object
	\|> Map.put("tag", tags)
	end

	defp strip_internal_tags(object), do: object

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

	q =
	from(
	u in User,
	where: ^old_follower_address in u.following,
	update: [
	set: [
	following:
	fragment(
	"array_replace(?,?,?)",
	u.following,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)

	Repo.update_all(q, [])

	maybe_retire_websub(user.ap_id)

	q =
	from(
	a in Activity,
	where: ^old_follower_address in a.recipients,
	update: [
	set: [
	recipients:
	fragment(
	"array_replace(?,?,?)",
	a.recipients,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)

	Repo.update_all(q, [])
	end

	- def upgrade_user_from_ap_id(ap_id, async \\ true) do
	+ def upgrade_user_from_ap_id(ap_id) do
	with %User{local: false} = user <- User.get_by_ap_id(ap_id),
	- {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
	- already_ap = User.ap_enabled?(user)
	-
	- {:ok, user} =
	- User.upgrade_changeset(user, data)
	- \|> Repo.update()
	-
	- if !already_ap do
	- # This could potentially take a long time, do it in the background
	- if async do
	- Task.start(fn ->
	- user_upgrade_task(user)
	- end)
	- else
	- user_upgrade_task(user)
	- end
	+ {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
	+ already_ap <- User.ap_enabled?(user),
	+ {:ok, user} <- user \|> User.upgrade_changeset(data) \|> User.update_and_set_cache() do
	+ unless already_ap do
	+ PleromaJobQueue.enqueue(:transmogrifier, __MODULE__, [:user_upgrade, user])
	end

	{:ok, user}
	else
	+ %User{} = user -> {:ok, user}
	e -> e
	end
	end

	def maybe_retire_websub(ap_id) do
	# some sanity checks
	if is_binary(ap_id) && String.length(ap_id) > 8 do
	q =
	from(
	ws in Pleroma.Web.Websub.WebsubClientSubscription,
	where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
	)

	Repo.delete_all(q)
	end
	end

	def maybe_fix_user_url(data) do
	if is_map(data["url"]) do
	Map.put(data, "url", data["url"]["href"])
	else
	data
	end
	end

	def maybe_fix_user_object(data) do
	data
	\|> maybe_fix_user_url
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index 32545937e..0b53f71c3 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,704 +1,707 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Ecto.Changeset
	alias Ecto.UUID
	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query

	require Logger

	@supported_object_types ["Article", "Note", "Video", "Page"]

	# Some implementations send the actor URI as the actor field, others send the entire actor object,
	# so figure out what the actor's URI is based on what we have.
	def get_ap_id(object) do
	case object do
	%{"id" => id} -> id
	id -> id
	end
	end

	def normalize_params(params) do
	Map.put(params, "actor", get_ap_id(params["actor"]))
	end

	def determine_explicit_mentions(%{"tag" => tag} = _object) when is_list(tag) do
	tag
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	end

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

	def determine_explicit_mentions(_), do: []

	defp recipient_in_collection(ap_id, coll) when is_binary(coll), do: ap_id == coll
	defp recipient_in_collection(ap_id, coll) when is_list(coll), do: ap_id in coll
	defp recipient_in_collection(_, _), do: false

	def recipient_in_message(ap_id, params) do
	cond do
	recipient_in_collection(ap_id, params["to"]) ->
	true

	recipient_in_collection(ap_id, params["cc"]) ->
	true

	recipient_in_collection(ap_id, params["bto"]) ->
	true

	recipient_in_collection(ap_id, params["bcc"]) ->
	true

	# if the message is unaddressed at all, then assume it is directly addressed
	# to the recipient
	!params["to"] && !params["cc"] && !params["bto"] && !params["bcc"] ->
	true

	true ->
	false
	end
	end

	defp extract_list(target) when is_binary(target), do: [target]
	defp extract_list(lst) when is_list(lst), do: lst
	defp extract_list(_), do: []

	def maybe_splice_recipient(ap_id, params) do
	need_splice =
	!recipient_in_collection(ap_id, params["to"]) &&
	!recipient_in_collection(ap_id, params["cc"])

	cc_list = extract_list(params["cc"])

	if need_splice do
	params
	\|> Map.put("cc", [ap_id \| cc_list])
	else
	params
	end
	end

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	- "#{Web.base_url()}/schemas/litepub-0.1.jsonld"
	+ "#{Web.base_url()}/schemas/litepub-0.1.jsonld",
	+ %{
	+ "@language" => "und"
	+ }
	]
	}
	end

	def make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601()
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Helpers.o_status_url(Endpoint, :object, UUID.generate())
	end

	def generate_id(type) do
	"#{Web.base_url()}/#{type}/#{UUID.generate()}"
	end

	def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
	fake_create_activity = %{
	"to" => object["to"],
	"cc" => object["cc"],
	"type" => "Create",
	"object" => object
	}

	Notification.get_notified_from_activity(%Activity{data: fake_create_activity}, false)
	end

	def get_notified_from_object(object) do
	Notification.get_notified_from_activity(%Activity{data: object}, false)
	end

	def create_context(context) do
	context = context \|\| generate_id("contexts")
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, object} ->
	object

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context)
	end
	end

	@doc """
	Enqueues an activity for federation if it's local
	"""
	def maybe_federate(%Activity{local: true} = activity) do
	priority =
	case activity.data["type"] do
	"Delete" -> 10
	"Create" -> 1
	_ -> 5
	end

	Pleroma.Web.Federator.publish(activity, priority)
	:ok
	end

	def maybe_federate(_), do: :ok

	@doc """
	Adds an id and a published data if they aren't there,
	also adds it to an included object
	"""
	def lazy_put_activity_defaults(map, fake \\ false) do
	map =
	unless fake do
	%{data: %{"id" => context}, id: context_id} = create_context(map["context"])

	map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", context)
	\|> Map.put_new("context_id", context_id)
	else
	map
	\|> Map.put_new("id", "pleroma:fakeid")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", "pleroma:fakecontext")
	\|> Map.put_new("context_id", -1)
	end

	if is_map(map["object"]) do
	object = lazy_put_object_defaults(map["object"], map, fake)
	%{map \| "object" => object}
	else
	map
	end
	end

	@doc """
	Adds an id and published date if they aren't there.
	"""
	def lazy_put_object_defaults(map, activity \\ %{}, fake)

	def lazy_put_object_defaults(map, activity, true = _fake) do
	map
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("id", "pleroma:fake_object_id")
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("fake", true)
	\|> Map.put_new("context_id", activity["context_id"])
	end

	def lazy_put_object_defaults(map, activity, _fake) do
	map
	\|> Map.put_new_lazy("id", &generate_object_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("context_id", activity["context_id"])
	end

	@doc """
	Inserts a full object if it is contained in an activity.
	"""
	def insert_full_object(%{"object" => %{"type" => type} = object_data})
	when is_map(object_data) and type in @supported_object_types do
	with {:ok, object} <- Object.create(object_data) do
	{:ok, object}
	end
	end

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

	def update_object_in_activities(%{data: %{"id" => id}} = object) do
	# TODO
	# Update activities that already had this. Could be done in a seperate process.
	# Alternatively, just don't do this and fetch the current object each time. Most
	# could probably be taken from cache.
	relevant_activities = Activity.get_all_create_by_object_ap_id(id)

	Enum.map(relevant_activities, fn activity ->
	new_activity_data = activity.data \|> Map.put("object", object.data)
	changeset = Changeset.change(activity, data: new_activity_data)
	Repo.update(changeset)
	end)
	end

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	where: fragment("(?)->>'actor' = ?", activity.data, ^actor),
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Like'", activity.data)
	)

	Repo.one(query)
	end

	@doc """
	Returns like activities targeting an object
	"""
	def get_object_likes(%{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Like'", activity.data)
	)

	Repo.all(query)
	end

	def make_like_data(
	%User{ap_id: ap_id} = actor,
	%{data: %{"actor" => object_actor_id, "id" => id}} = object,
	activity_id
	) do
	object_actor = User.get_cached_by_ap_id(object_actor_id)

	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	data = %{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def update_element_in_object(property, element, object) do
	with new_data <-
	object.data
	\|> Map.put("#{property}_count", length(element))
	\|> Map.put("#{property}s", element),
	changeset <- Changeset.change(object, data: new_data),
	{:ok, object} <- Object.update_and_set_cache(changeset),
	_ <- update_object_in_activities(object) do
	{:ok, object}
	end
	end

	def update_likes_in_object(likes, object) do
	update_element_in_object("like", likes, object)
	end

	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

	with likes <- [actor \| likes] \|> Enum.uniq() do
	update_likes_in_object(likes, object)
	end
	end

	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

	with likes <- likes \|> List.delete(actor) do
	update_likes_in_object(likes, object)
	end
	end

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	def update_follow_state(
	%Activity{data: %{"actor" => actor, "object" => object, "state" => "pending"}} = activity,
	state
	) do
	try do
	Ecto.Adapters.SQL.query!(
	Repo,
	"UPDATE activities SET data = jsonb_set(data, '{state}', $1) WHERE data->>'type' = 'Follow' AND data->>'actor' = $2 AND data->>'object' = $3 AND data->>'state' = 'pending'",
	[state, actor, object]
	)

	activity = Activity.get_by_id(activity.id)
	{:ok, activity}
	rescue
	e ->
	{:error, e}
	end
	end

	def update_follow_state(%Activity{} = activity, state) do
	with new_data <-
	activity.data
	\|> Map.put("state", state),
	changeset <- Changeset.change(activity, data: new_data),
	{:ok, activity} <- Repo.update(changeset) do
	{:ok, activity}
	end
	end

	@doc """
	Makes a follow activity data for the given follower and followed
	"""
	def make_follow_data(
	%User{ap_id: follower_id},
	%User{ap_id: followed_id} = _followed,
	activity_id
	) do
	data = %{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => followed_id,
	"state" => "pending"
	}

	data = if activity_id, do: Map.put(data, "id", activity_id), else: data

	data
	end

	def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
	query =
	from(
	activity in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Follow'",
	activity.data
	),
	where: activity.actor == ^follower_id,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^followed_id
	),
	order_by: [fragment("? desc nulls last", activity.id)],
	limit: 1
	)

	Repo.one(query)
	end

	#### Announce-related helpers

	@doc """
	Retruns an existing announce activity if the notice has already been announced
	"""
	def get_existing_announce(actor, %{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	where: activity.actor == ^actor,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Announce'", activity.data)
	)

	Repo.one(query)
	end

	@doc """
	Make announce activity data for the given actor and object
	"""
	# for relayed messages, we only want to send to subscribers
	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	false
	) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address],
	"cc" => [],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	true
	) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	@doc """
	Make unannounce activity data for the given actor and object
	"""
	def make_unannounce_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context}} = activity,
	activity_id
	) do
	data = %{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => context
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_unlike_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context}} = activity,
	activity_id
	) do
	data = %{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => context
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def add_announce_to_object(
	%Activity{
	data: %{"actor" => actor, "cc" => ["https://www.w3.org/ns/activitystreams#Public"]}
	},
	object
	) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

	with announcements <- [actor \| announcements] \|> Enum.uniq() do
	update_element_in_object("announcement", announcements, object)
	end
	end

	def add_announce_to_object(_, object), do: {:ok, object}

	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

	with announcements <- announcements \|> List.delete(actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	#### Unfollow-related helpers

	def make_unfollow_data(follower, followed, follow_activity, activity_id) do
	data = %{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	"object" => follow_activity.data
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Block-related helpers
	def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	query =
	from(
	activity in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Block'",
	activity.data
	),
	where: activity.actor == ^blocker_id,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^blocked_id
	),
	order_by: [fragment("? desc nulls last", activity.id)],
	limit: 1
	)

	Repo.one(query)
	end

	def make_block_data(blocker, blocked, activity_id) do
	data = %{
	"type" => "Block",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => blocked.ap_id
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_unblock_data(blocker, blocked, block_activity, activity_id) do
	data = %{
	"type" => "Undo",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => block_activity.data
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Create-related helpers

	def make_create_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	#### Flag-related helpers

	def make_flag_data(params, additional) do
	status_ap_ids =
	Enum.map(params.statuses \|\| [], fn
	%Activity{} = act -> act.data["id"]
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end)

	object = [params.account.ap_id] ++ status_ap_ids

	%{
	"type" => "Flag",
	"actor" => params.actor.ap_id,
	"content" => params.content,
	"object" => object,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	@doc """
	Fetches the OrderedCollection/OrderedCollectionPage from `from`, limiting the amount of pages fetched after
	the first one to `pages_left` pages.
	If the amount of pages is higher than the collection has, it returns whatever was there.
	"""
	def fetch_ordered_collection(from, pages_left, acc \\ []) do
	with {:ok, response} <- Tesla.get(from),
	{:ok, collection} <- Poison.decode(response.body) do
	case collection["type"] do
	"OrderedCollection" ->
	# If we've encountered the OrderedCollection and not the page,
	# just call the same function on the page address
	fetch_ordered_collection(collection["first"], pages_left)

	"OrderedCollectionPage" ->
	if pages_left > 0 do
	# There are still more pages
	if Map.has_key?(collection, "next") do
	# There are still more pages, go deeper saving what we have into the accumulator
	fetch_ordered_collection(
	collection["next"],
	pages_left - 1,
	acc ++ collection["orderedItems"]
	)
	else
	# No more pages left, just return whatever we already have
	acc ++ collection["orderedItems"]
	end
	else
	# Got the amount of pages needed, add them all to the accumulator
	acc ++ collection["orderedItems"]
	end

	_ ->
	{:error, "Not an OrderedCollection or OrderedCollectionPage"}
	end
	end
	end
	end
	diff --git a/lib/pleroma/web/auth/authenticator.ex b/lib/pleroma/web/auth/authenticator.ex
	index 043e3ad33..b0d57d4f1 100644
	--- a/lib/pleroma/web/auth/authenticator.ex
	+++ b/lib/pleroma/web/auth/authenticator.ex
	@@ -1,48 +1,71 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.Authenticator do
	+ alias Pleroma.Registration
	alias Pleroma.User

	def implementation do
	Pleroma.Config.get(
	Pleroma.Web.Auth.Authenticator,
	Pleroma.Web.Auth.PleromaAuthenticator
	)
	end

	- @callback get_user(Plug.Conn.t()) :: {:ok, User.t()} \| {:error, any()}
	- def get_user(plug), do: implementation().get_user(plug)
	+ @callback get_user(Plug.Conn.t(), Map.t()) :: {:ok, User.t()} \| {:error, any()}
	+ def get_user(plug, params), do: implementation().get_user(plug, params)
	+
	+ @callback create_from_registration(Plug.Conn.t(), Map.t(), Registration.t()) ::
	+ {:ok, User.t()} \| {:error, any()}
	+ def create_from_registration(plug, params, registration),
	+ do: implementation().create_from_registration(plug, params, registration)
	+
	+ @callback get_registration(Plug.Conn.t(), Map.t()) ::
	+ {:ok, Registration.t()} \| {:error, any()}
	+ def get_registration(plug, params),
	+ do: implementation().get_registration(plug, params)

	@callback handle_error(Plug.Conn.t(), any()) :: any()
	def handle_error(plug, error), do: implementation().handle_error(plug, error)

	@callback auth_template() :: String.t() \| nil
	def auth_template do
	- implementation().auth_template() \|\| Pleroma.Config.get(:auth_template, "show.html")
	+ # Note: `config :pleroma, :auth_template, "..."` support is deprecated
	+ implementation().auth_template() \|\|
	+ Pleroma.Config.get([:auth, :auth_template], Pleroma.Config.get(:auth_template)) \|\|
	+ "show.html"
	+ end
	+
	+ @callback oauth_consumer_template() :: String.t() \| nil
	+ def oauth_consumer_template do
	+ implementation().oauth_consumer_template() \|\|
	+ Pleroma.Config.get([:auth, :oauth_consumer_template], "consumer.html")
	end

	@doc "Gets user by nickname or email for auth."
	@spec fetch_user(String.t()) :: User.t() \| nil
	def fetch_user(name) do
	User.get_by_nickname_or_email(name)
	end

	# Gets name and password from conn
	#
	- @spec fetch_credentials(Plug.Conn.t()) ::
	+ @spec fetch_credentials(Plug.Conn.t() \| map()) ::
	{:ok, {name :: any, password :: any}} \| {:error, :invalid_credentials}
	- def fetch_credentials(%Plug.Conn{} = conn) do
	- case conn.params do
	+ def fetch_credentials(%Plug.Conn{params: params} = _),
	+ do: fetch_credentials(params)
	+
	+ def fetch_credentials(params) do
	+ case params do
	%{"authorization" => %{"name" => name, "password" => password}} ->
	{:ok, {name, password}}

	%{"grant_type" => "password", "username" => name, "password" => password} ->
	{:ok, {name, password}}

	_ ->
	{:error, :invalid_credentials}
	end
	end
	end
	diff --git a/lib/pleroma/web/auth/ldap_authenticator.ex b/lib/pleroma/web/auth/ldap_authenticator.ex
	index 8bf9cf32e..2bf589b07 100644
	--- a/lib/pleroma/web/auth/ldap_authenticator.ex
	+++ b/lib/pleroma/web/auth/ldap_authenticator.ex
	@@ -1,138 +1,144 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.LDAPAuthenticator do
	alias Pleroma.User
	- alias Pleroma.Web.Auth.PleromaAuthenticator

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

	require Logger

	@behaviour Pleroma.Web.Auth.Authenticator
	+ @base Pleroma.Web.Auth.PleromaAuthenticator

	@connection_timeout 10_000
	@search_timeout 10_000

	- def get_user(%Plug.Conn{} = conn) do
	+ defdelegate get_registration(conn, params), to: @base
	+
	+ defdelegate create_from_registration(conn, params, registration), to: @base
	+
	+ def get_user(%Plug.Conn{} = conn, params) do
	if Pleroma.Config.get([:ldap, :enabled]) do
	- with {:ok, {name, password}} <- fetch_credentials(conn),
	+ with {:ok, {name, password}} <- fetch_credentials(params),
	%User{} = user <- ldap_user(name, password) do
	{:ok, user}
	else
	{:error, {:ldap_connection_error, _}} ->
	# When LDAP is unavailable, try default authenticator
	- PleromaAuthenticator.get_user(conn)
	+ @base.get_user(conn, params)

	error ->
	error
	end
	else
	# Fall back to default authenticator
	- PleromaAuthenticator.get_user(conn)
	+ @base.get_user(conn, params)
	end
	end

	def handle_error(%Plug.Conn{} = _conn, error) do
	error
	end

	def auth_template, do: nil

	+ def oauth_consumer_template, do: nil
	+
	defp ldap_user(name, password) do
	ldap = Pleroma.Config.get(:ldap, [])
	host = Keyword.get(ldap, :host, "localhost")
	port = Keyword.get(ldap, :port, 389)
	ssl = Keyword.get(ldap, :ssl, false)
	sslopts = Keyword.get(ldap, :sslopts, [])

	options =
	[{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}] ++
	if sslopts != [], do: [{:sslopts, sslopts}], else: []

	case :eldap.open([to_charlist(host)], options) do
	{:ok, connection} ->
	try do
	if Keyword.get(ldap, :tls, false) do
	:application.ensure_all_started(:ssl)

	case :eldap.start_tls(
	connection,
	Keyword.get(ldap, :tlsopts, []),
	@connection_timeout
	) do
	:ok ->
	:ok

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

	bind_user(connection, ldap, name, password)
	after
	:eldap.close(connection)
	end

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

	defp bind_user(connection, ldap, name, password) do
	uid = Keyword.get(ldap, :uid, "cn")
	base = Keyword.get(ldap, :base)

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

	_ ->
	register_user(connection, base, uid, name, password)
	end

	error ->
	error
	end
	end

	defp register_user(connection, base, uid, name, password) do
	case :eldap.search(connection, [
	{:base, to_charlist(base)},
	{:filter, :eldap.equalityMatch(to_charlist(uid), to_charlist(name))},
	{:scope, :eldap.wholeSubtree()},
	{:attributes, ['mail', 'email']},
	{:timeout, @search_timeout}
	]) do
	{:ok, {:eldap_search_result, [{:eldap_entry, _, attributes}], _}} ->
	with {_, [mail]} <- List.keyfind(attributes, 'mail', 0) do
	params = %{
	email: :erlang.list_to_binary(mail),
	name: name,
	nickname: name,
	password: password,
	password_confirmation: password
	}

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

	case User.register(changeset) do
	{:ok, user} -> user
	error -> error
	end
	else
	_ ->
	Logger.error("Could not find LDAP attribute mail: #{inspect(attributes)}")
	{:error, :ldap_registration_missing_attributes}
	end

	error ->
	error
	end
	end
	end
	diff --git a/lib/pleroma/web/auth/pleroma_authenticator.ex b/lib/pleroma/web/auth/pleroma_authenticator.ex
	index dd73097db..6629b4ca1 100644
	--- a/lib/pleroma/web/auth/pleroma_authenticator.ex
	+++ b/lib/pleroma/web/auth/pleroma_authenticator.ex
	@@ -1,38 +1,100 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.PleromaAuthenticator do
	alias Comeonin.Pbkdf2
	+ alias Pleroma.Registration
	+ alias Pleroma.Repo
	alias Pleroma.User

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

	@behaviour Pleroma.Web.Auth.Authenticator

	- def get_user(%Plug.Conn{} = conn) do
	- with {:ok, {name, password}} <- fetch_credentials(conn),
	+ def get_user(%Plug.Conn{} = _conn, params) do
	+ with {:ok, {name, password}} <- fetch_credentials(params),
	{_, %User{} = user} <- {:user, fetch_user(name)},
	{:ok, _user} <- {authenticate(user, password), user} do
	{:ok, user}
	else
	{:error, reason} -> {:error, reason}
	error -> {:error, error}
	end
	end

	+ def get_registration(
	+ %Plug.Conn{assigns: %{ueberauth_auth: %{provider: provider, uid: uid} = auth}},
	+ _params
	+ ) do
	+ registration = Registration.get_by_provider_uid(provider, uid)
	+
	+ if registration do
	+ {:ok, registration}
	+ else
	+ info = auth.info
	+
	+ Registration.changeset(%Registration{}, %{
	+ provider: to_string(provider),
	+ uid: to_string(uid),
	+ info: %{
	+ "nickname" => info.nickname,
	+ "email" => info.email,
	+ "name" => info.name,
	+ "description" => info.description
	+ }
	+ })
	+ \|> Repo.insert()
	+ end
	+ end
	+
	+ def get_registration(%Plug.Conn{} = _conn, _params), do: {:error, :missing_credentials}
	+
	+ def create_from_registration(_conn, params, registration) do
	+ nickname = value([params["nickname"], Registration.nickname(registration)])
	+ email = value([params["email"], Registration.email(registration)])
	+ name = value([params["name"], Registration.name(registration)]) \|\| nickname
	+ bio = value([params["bio"], Registration.description(registration)])
	+
	+ random_password = :crypto.strong_rand_bytes(64) \|> Base.encode64()
	+
	+ with {:ok, new_user} <-
	+ User.register_changeset(
	+ %User{},
	+ %{
	+ email: email,
	+ nickname: nickname,
	+ name: name,
	+ bio: bio,
	+ password: random_password,
	+ password_confirmation: random_password
	+ },
	+ external: true,
	+ confirmed: true
	+ )
	+ \|> Repo.insert(),
	+ {:ok, _} <-
	+ Registration.changeset(registration, %{user_id: new_user.id}) \|> Repo.update() do
	+ {:ok, new_user}
	+ end
	+ end
	+
	+ defp value(list), do: Enum.find(list, &(to_string(&1) != ""))
	+
	def handle_error(%Plug.Conn{} = _conn, error) do
	error
	end

	def auth_template, do: nil

	+ def oauth_consumer_template, do: nil
	+
	def authenticate(%User{password_hash: hash} = _user, password) do
	if Pbkdf2.checkpw(password, hash) do
	:ok
	else
	:error
	end
	end
	end
	diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
	index 745d1839b..74babdf14 100644
	--- a/lib/pleroma/web/common_api/common_api.ex
	+++ b/lib/pleroma/web/common_api/common_api.ex
	@@ -1,321 +1,321 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI do
	alias Pleroma.Activity
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils

	import Pleroma.Web.CommonAPI.Utils

	def follow(follower, followed) do
	with {:ok, follower} <- User.maybe_direct_follow(follower, followed),
	{:ok, activity} <- ActivityPub.follow(follower, followed),
	{:ok, follower, followed} <-
	User.wait_and_refresh(
	Pleroma.Config.get([:activitypub, :follow_handshake_timeout]),
	follower,
	followed
	) do
	{:ok, follower, followed, activity}
	end
	end

	def unfollow(follower, unfollowed) do
	with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
	{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed) do
	{:ok, follower}
	end
	end

	def accept_follow_request(follower, followed) do
	with {:ok, follower} <- User.maybe_follow(follower, followed),
	%Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
	{:ok, _activity} <-
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Accept"
	}) do
	{:ok, follower}
	end
	end

	def reject_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
	{:ok, _activity} <-
	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Reject"
	}) do
	{:ok, follower}
	end
	end

	def delete(activity_id, user) do
	with %Activity{data: %{"object" => _}} = activity <-
	Activity.get_by_id_with_object(activity_id),
	%Object{} = object <- Object.normalize(activity),
	true <- User.superuser?(user) \|\| user.ap_id == object.data["actor"],
	{:ok, _} <- unpin(activity_id, user),
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	end
	end

	def repeat(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity),
	nil <- Utils.get_existing_announce(user.ap_id, object) do
	ActivityPub.announce(user, object)
	else
	_ ->
	{:error, "Could not repeat"}
	end
	end

	def unrepeat(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity) do
	ActivityPub.unannounce(user, object)
	else
	_ ->
	{:error, "Could not unrepeat"}
	end
	end

	def favorite(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity),
	nil <- Utils.get_existing_like(user.ap_id, object) do
	ActivityPub.like(user, object)
	else
	_ ->
	{:error, "Could not favorite"}
	end
	end

	def unfavorite(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity) do
	ActivityPub.unlike(user, object)
	else
	_ ->
	{:error, "Could not unfavorite"}
	end
	end

	def get_visibility(%{"visibility" => visibility})
	when visibility in ~w{public unlisted private direct},
	do: visibility

	def get_visibility(%{"in_reply_to_status_id" => status_id}) when not is_nil(status_id) do
	case get_replied_to_activity(status_id) do
	nil ->
	"public"

	in_reply_to ->
	Pleroma.Web.MastodonAPI.StatusView.get_visibility(in_reply_to.data["object"])
	end
	end

	def get_visibility(_), do: "public"

	def post(user, %{"status" => status} = data) do
	visibility = get_visibility(data)
	limit = Pleroma.Config.get([:instance, :limit])

	with status <- String.trim(status),
	attachments <- attachments_from_ids(data),
	in_reply_to <- get_replied_to_activity(data["in_reply_to_status_id"]),
	{content_html, mentions, tags} <-
	make_content_html(
	status,
	attachments,
	data,
	visibility
	),
	{to, cc} <- to_for_user_and_mentions(user, mentions, in_reply_to, visibility),
	context <- make_context(in_reply_to),
	cw <- data["spoiler_text"],
	full_payload <- String.trim(status <> (data["spoiler_text"] \|\| "")),
	length when length in 1..limit <- String.length(full_payload),
	object <-
	make_note_data(
	user.ap_id,
	to,
	context,
	content_html,
	attachments,
	in_reply_to,
	tags,
	cw,
	cc
	),
	object <-
	Map.put(
	object,
	"emoji",
	(Formatter.get_emoji(status) ++ Formatter.get_emoji(data["spoiler_text"]))
	- \|> Enum.reduce(%{}, fn {name, file}, acc ->
	+ \|> Enum.reduce(%{}, fn {name, file, _}, acc ->
	Map.put(acc, name, "#{Pleroma.Web.Endpoint.static_url()}#{file}")
	end)
	) do
	res =
	ActivityPub.create(
	%{
	to: to,
	actor: user,
	context: context,
	object: object,
	additional: %{"cc" => cc, "directMessage" => visibility == "direct"}
	},
	Pleroma.Web.ControllerHelper.truthy_param?(data["preview"]) \|\| false
	)

	res
	end
	end

	# Updates the emojis for a user based on their profile
	def update(user) do
	user =
	with emoji <- emoji_from_profile(user),
	source_data <- (user.info.source_data \|\| %{}) \|> Map.put("tag", emoji),
	info_cng <- Pleroma.User.Info.set_source_data(user.info, source_data),
	change <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, user} <- User.update_and_set_cache(change) do
	user
	else
	_e ->
	user
	end

	ActivityPub.update(%{
	local: true,
	to: [user.follower_address],
	cc: [],
	actor: user.ap_id,
	object: Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
	})
	end

	def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
	with %Activity{
	actor: ^user_ap_id,
	data: %{
	"type" => "Create",
	"object" => %{
	"to" => object_to,
	"type" => "Note"
	}
	}
	} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	true <- Enum.member?(object_to, "https://www.w3.org/ns/activitystreams#Public"),
	%{valid?: true} = info_changeset <-
	Pleroma.User.Info.add_pinnned_activity(user.info, activity),
	changeset <-
	Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	{:ok, activity}
	else
	%{errors: [pinned_activities: {err, _}]} ->
	{:error, err}

	_ ->
	{:error, "Could not pin"}
	end
	end

	def unpin(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	%{valid?: true} = info_changeset <-
	Pleroma.User.Info.remove_pinnned_activity(user.info, activity),
	changeset <-
	Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	{:ok, activity}
	else
	%{errors: [pinned_activities: {err, _}]} ->
	{:error, err}

	_ ->
	{:error, "Could not unpin"}
	end
	end

	def add_mute(user, activity) do
	with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]) do
	{:ok, activity}
	else
	{:error, _} -> {:error, "conversation is already muted"}
	end
	end

	def remove_mute(user, activity) do
	ThreadMute.remove_mute(user.id, activity.data["context"])
	{:ok, activity}
	end

	def thread_muted?(%{id: nil} = _user, _activity), do: false

	def thread_muted?(user, activity) do
	with [] <- ThreadMute.check_muted(user.id, activity.data["context"]) do
	false
	else
	_ -> true
	end
	end

	def report(user, data) do
	with {:account_id, %{"account_id" => account_id}} <- {:account_id, data},
	{:account, %User{} = account} <- {:account, User.get_by_id(account_id)},
	{:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]),
	{:ok, statuses} <- get_report_statuses(account, data),
	{:ok, activity} <-
	ActivityPub.flag(%{
	context: Utils.generate_context_id(),
	actor: user,
	account: account,
	statuses: statuses,
	content: content_html,
	forward: data["forward"] \|\| false
	}) do
	{:ok, activity}
	else
	{:error, err} -> {:error, err}
	{:account_id, %{}} -> {:error, "Valid `account_id` required"}
	{:account, nil} -> {:error, "Account not found"}
	end
	end

	def hide_reblogs(user, muted) do
	ap_id = muted.ap_id

	if ap_id not in user.info.muted_reblogs do
	info_changeset = User.Info.add_reblog_mute(user.info, ap_id)
	changeset = Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset)
	User.update_and_set_cache(changeset)
	end
	end

	def show_reblogs(user, muted) do
	ap_id = muted.ap_id

	if ap_id in user.info.muted_reblogs do
	info_changeset = User.Info.remove_reblog_mute(user.info, ap_id)
	changeset = Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset)
	User.update_and_set_cache(changeset)
	end
	end
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index 9cd8b3758..051db6c79 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,393 +1,393 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Utils do
	alias Calendar.Strftime
	alias Comeonin.Pbkdf2
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

	require Logger

	# This is a hack for twidere.
	def get_by_id_or_ap_id(id) do
	activity =
	Activity.get_by_id_with_object(id) \|\| Activity.get_create_by_object_ap_id_with_object(id)

	activity &&
	if activity.data["type"] == "Create" do
	activity
	else
	Activity.get_create_by_object_ap_id_with_object(activity.data["object"])
	end
	end

	def get_replied_to_activity(""), do: nil

	def get_replied_to_activity(id) when not is_nil(id) do
	Activity.get_by_id(id)
	end

	def get_replied_to_activity(_), do: nil

	def attachments_from_ids(data) do
	if Map.has_key?(data, "descriptions") do
	attachments_from_ids_descs(data["media_ids"], data["descriptions"])
	else
	attachments_from_ids_no_descs(data["media_ids"])
	end
	end

	def attachments_from_ids_no_descs(ids) do
	Enum.map(ids \|\| [], fn media_id ->
	Repo.get(Object, media_id).data
	end)
	end

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

	Enum.map(ids \|\| [], fn media_id ->
	Map.put(Repo.get(Object, media_id).data, "name", descs[media_id])
	end)
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "public") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	to = ["https://www.w3.org/ns/activitystreams#Public" \| mentioned_users]
	cc = [user.follower_address]

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

	def to_for_user_and_mentions(user, mentions, inReplyTo, "unlisted") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	to = [user.follower_address \| mentioned_users]
	cc = ["https://www.w3.org/ns/activitystreams#Public"]

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

	def to_for_user_and_mentions(user, mentions, inReplyTo, "private") do
	{to, cc} = to_for_user_and_mentions(user, mentions, inReplyTo, "direct")
	{[user.follower_address \| to], cc}
	end

	def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| mentioned_users]), []}
	else
	{mentioned_users, []}
	end
	end

	def make_content_html(
	status,
	attachments,
	data,
	visibility
	) do
	no_attachment_links =
	data
	\|> Map.get("no_attachment_links", Config.get([:instance, :no_attachment_links]))
	\|> Kernel.in([true, "true"])

	content_type = get_content_type(data["content_type"])

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

	status
	\|> format_input(content_type, options)
	\|> maybe_add_attachments(attachments, no_attachment_links)
	\|> maybe_add_nsfw_tag(data)
	end

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

	defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
	when sensitive in [true, "True", "true", "1"] do
	{text, mentions, [{"#nsfw", "nsfw"} \| tags]}
	end

	defp maybe_add_nsfw_tag(data, _), do: data

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

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

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

	def add_attachments(text, attachments) do
	attachment_text =
	Enum.map(attachments, fn
	%{"url" => [%{"href" => href} \| _]} = attachment ->
	name = attachment["name"] \|\| URI.decode(Path.basename(href))
	href = MediaProxy.url(href)
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"

	_ ->
	""
	end)

	Enum.join([text \| attachment_text], "<br>")
	end

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

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

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

	@doc """
	Formatting text to markdown.
	"""
	def format_input(text, "text/markdown", options) do
	options = Keyword.put(options, :mentions_escape, true)

	text
	\|> Formatter.linkify(options)
	\|> (fn {text, mentions, tags} -> {Earmark.as_html!(text), mentions, tags} end).()
	\|> Formatter.html_escape("text/html")
	end

	def make_note_data(
	actor,
	to,
	context,
	content_html,
	attachments,
	inReplyTo,
	tags,
	cw \\ nil,
	cc \\ []
	) do
	object = %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => content_html,
	"summary" => cw,
	"context" => context,
	"attachment" => attachments,
	"actor" => actor,
	"tag" => tags \|> Enum.map(fn {_, tag} -> tag end) \|> Enum.uniq()
	}

	if inReplyTo do
	object
	\|> Map.put("inReplyTo", inReplyTo.data["object"]["id"])
	\|> Map.put("inReplyToStatusId", inReplyTo.id)
	else
	object
	end
	end

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

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

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

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

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

	def to_masto_date(date) do
	try do
	date
	\|> NaiveDateTime.from_iso8601!()
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	rescue
	_e -> ""
	end
	end

	defp shortname(name) do
	if String.length(name) < 30 do
	name
	else
	String.slice(name, 0..30) <> "…"
	end
	end

	def confirm_current_password(user, password) do
	with %User{local: true} = db_user <- User.get_by_id(user.id),
	true <- Pbkdf2.checkpw(password, db_user.password_hash) do
	{:ok, db_user}
	else
	_ -> {:error, "Invalid password."}
	end
	end

	def emoji_from_profile(%{info: _info} = user) do
	(Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
	- \|> Enum.map(fn {shortcode, url} ->
	+ \|> Enum.map(fn {shortcode, url, _} ->
	%{
	"type" => "Emoji",
	"icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
	"name" => ":#{shortcode}:"
	}
	end)
	end

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

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

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

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

	true ->
	%{}
	end

	tagged_mentions = maybe_extract_mentions(object_data)

	recipients ++ tagged_mentions
	end

	def maybe_notify_mentioned_recipients(recipients, _), do: recipients

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

	def maybe_extract_mentions(_), do: []

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

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

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

	def get_report_statuses(%User{ap_id: actor}, %{"status_ids" => status_ids}) do
	{:ok, Activity.all_by_actor_and_id(actor, status_ids)}
	end

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

	# DEPRECATED mostly, context objects are now created at insertion time.
	def context_to_conversation_id(context) do
	with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
	id
	else
	_e ->
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, %{id: id}} ->
	id

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context).id
	end
	end
	end

	def conversation_id_to_context(id) do
	with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
	context
	else
	_e ->
	{:error, "No such conversation"}
	end
	end
	end
	diff --git a/lib/pleroma/web/endpoint.ex b/lib/pleroma/web/endpoint.ex
	index 6d9528c86..1633477c3 100644
	--- a/lib/pleroma/web/endpoint.ex
	+++ b/lib/pleroma/web/endpoint.ex
	@@ -1,110 +1,120 @@
	# 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)

	# 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: "/")

	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)
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	)

	# 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 Application.get_env(:pleroma, Pleroma.Web.Endpoint) \|> Keyword.get(:secure_cookie_flag),
	+ if secure_cookies,
	do: "__Host-pleroma_key",
	else: "pleroma_key"

	+ same_site =
	+ if Pleroma.Config.oauth_consumer_enabled?() do
	+ # Note: "SameSite=Strict" prevents sign in with external OAuth provider
	+ # (there would be no cookies during callback request from OAuth provider)
	+ "SameSite=Lax"
	+ else
	+ "SameSite=Strict"
	+ end
	+
	# 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:
	- Application.get_env(:pleroma, Pleroma.Web.Endpoint) \|> Keyword.get(:secure_cookie_flag),
	- extra: "SameSite=Strict"
	+ secure: secure_cookies,
	+ extra: same_site
	)

	# 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/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index fc8a2458c..5462ce8be 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,1608 +1,1609 @@
	# 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.Config
	alias Pleroma.Filter
	alias Pleroma.Notification
	alias Pleroma.Object
	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.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.Token

	import Pleroma.Web.ControllerHelper, only: [oauth_scopes: 2]
	import Ecto.Query

	require Logger

	@httpoison Application.get_env(:pleroma, :httpoison)
	@local_mastodon_name "Mastodon-Local"

	action_fallback(:errors)

	def create_app(conn, params) do
	scopes = oauth_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)} 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)

	info_params =
	%{}
	\|> add_if_present(params, "locked", :locked, fn value -> {:ok, value == "true"} end)
	\|> add_if_present(params, "header", :banner, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :banner) do
	{:ok, object.data}
	else
	_ -> :error
	end
	end)

	info_cng = User.Info.mastodon_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.5.0"

	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} ->
	+ \|> 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
	+ "url" => url,
	+ "tags" => String.split(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"])
	\|> Map.merge(params)

	last = List.last(activities)
	first = List.first(activities)

	if last do
	min = last.id
	max = first.id

	{next_url, prev_url} =
	if param do
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{max_id: min})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{since_id: max})
	)
	}
	else
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{max_id: min})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{since_id: max})
	)
	}
	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)
	\|> ActivityPub.contain_timeline(user)
	\|> 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_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)
	\|> Repo.all()

	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(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) 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(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(id),
	%User{} = user <- User.get_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, user} <- User.bookmark(user, activity.data["object"]["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(id),
	%User{} = user <- User.get_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	{:ok, user} <- User.unbookmark(user, activity.data["object"]["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 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 favourited_by(conn, %{"id" => id}) do
	with %Activity{data: %{"object" => %{"likes" => likes}}} <- Activity.get_by_id(id) do
	q = from(u in User, where: u.ap_id in ^likes)
	users = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render(AccountView, "accounts.json", %{users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

	def reblogged_by(conn, %{"id" => id}) do
	with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Activity.get_by_id(id) do
	q = from(u in User, where: u.ap_id in ^announces)
	users = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{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_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", %{users: followers, as: :user})
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
	with %User{} = user <- User.get_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", %{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", %{users: follow_requests, as: :user})
	end
	end

	def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
	with %User{} = follower <- User.get_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_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 <- User.get_by_id(id),
	false <- User.following?(follower, followed),
	{:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	else
	true ->
	followed = User.get_cached_by_id(id)

	{:ok, follower} =
	case conn.params["reblogs"] do
	true -> CommonAPI.show_reblogs(follower, followed)
	false -> CommonAPI.hide_reblogs(follower, followed)
	end

	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})

	{: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 <- User.get_by_nickname(uri),
	{:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("account.json", %{user: followed, for: follower})
	else
	{: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 <- User.get_by_id(id),
	{:ok, follower} <- CommonAPI.unfollow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	end
	end

	def mute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
	with %User{} = muted <- User.get_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_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_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_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 status_search(user, query) do
	fetched =
	if Regex.match?(~r/https?:/, query) do
	with {:ok, object} <- ActivityPub.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 in Activity,
	where: fragment("?->>'type' = 'Create'", a.data),
	where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
	where:
	fragment(
	"to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
	a.data,
	^query
	),
	limit: 20,
	order_by: [desc: :id]
	)

	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 bookmarks(%{assigns: %{user: user}} = conn, _) do
	user = User.get_by_id(user.id)

	activities =
	user.bookmarks
	\|> Enum.map(fn id -> Activity.get_create_by_object_ap_id(id) end)
	\|> Enum.reverse()

	conn
	\|> 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_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 <- Pleroma.User.get_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", %{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:
	String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"),
	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: "/images/pleroma-fox-tan-smol.png"
	},
	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_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", nil),
	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(
	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
	%{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 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/oauth/fallback_controller.ex b/lib/pleroma/web/oauth/fallback_controller.ex
	index 0c1871afa..99ef5d209 100644
	--- a/lib/pleroma/web/oauth/fallback_controller.ex
	+++ b/lib/pleroma/web/oauth/fallback_controller.ex
	@@ -1,32 +1,45 @@
	# 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.FallbackController do
	use Pleroma.Web, :controller
	alias Pleroma.Web.OAuth.OAuthController

	# Two-factor authentication step is failed."
	#
	def call(conn, {:error, :verify_2fa_failded}) do
	conn
	\|> put_status(400)
	\|> json(%{error_code: "2fa_failed", error: "Two-factor authentication failed."})
	end

	# login or password incorrect
	#
	def call(conn, {:error, :invalid_credentails}) do
	conn
	\|> put_status(400)
	\|> json(%{error_code: "invalid_credentails", error: "Invalid credentials"})
	end

	- # No user/password
	- def call(conn, _) do
	+ def call(conn, {:register, :generic_error}) do
	+ conn
	+ \|> put_status(:internal_server_error)
	+ \|> put_flash(:error, "Unknown error, please check the details and try again.")
	+ \|> OAuthController.registration_details(conn.params)
	+ end
	+
	+ def call(conn, {:register, _error}) do
	+ conn
	+ \|> put_status(:unauthorized)
	+ \|> put_flash(:error, "Invalid Username/Password")
	+ \|> OAuthController.registration_details(conn.params)
	+ end
	+
	+ def call(conn, _error) do
	conn
	\|> put_status(:unauthorized)
	\|> put_flash(:error, "Invalid Username/Password")
	\|> OAuthController.authorize(conn.params["authorization"])
	end
	end
	diff --git a/lib/pleroma/web/oauth/oauth_controller.ex b/lib/pleroma/web/oauth/oauth_controller.ex
	index 6b44a57ad..3f12e8d7e 100644
	--- a/lib/pleroma/web/oauth/oauth_controller.ex
	+++ b/lib/pleroma/web/oauth/oauth_controller.ex
	@@ -1,291 +1,476 @@
	# 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.OAuthController do
	use Pleroma.Web, :controller

	+ alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.Auth.Authenticator
	alias Pleroma.Web.Auth.TOTPAuthenticator
	alias Pleroma.Web.ControllerHelper
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

	import Pleroma.Web.ControllerHelper, only: [oauth_scopes: 2]

	+ if Pleroma.Config.oauth_consumer_enabled?(), do: plug(Ueberauth)
	+
	plug(:fetch_session)
	plug(:fetch_flash)

	action_fallback(Pleroma.Web.OAuth.FallbackController)

	def authorize(%{assigns: %{token: %Token{} = token}} = conn, params) do
	if ControllerHelper.truthy_param?(params["force_login"]) do
	do_authorize(conn, params)
	else
	redirect_uri =
	if is_binary(params["redirect_uri"]) do
	params["redirect_uri"]
	else
	app = Repo.preload(token, :app).app

	app.redirect_uris
	\|> String.split()
	\|> Enum.at(0)
	end

	redirect(conn, external: redirect_uri(conn, redirect_uri))
	end
	end

	def authorize(conn, params), do: do_authorize(conn, params)

	defp do_authorize(conn, params) do
	app = Repo.get_by(App, client_id: params["client_id"])
	available_scopes = (app && app.scopes) \|\| []
	scopes = oauth_scopes(params, nil) \|\| available_scopes

	render(conn, Authenticator.auth_template(), %{
	response_type: params["response_type"],
	client_id: params["client_id"],
	available_scopes: available_scopes,
	scopes: scopes,
	redirect_uri: params["redirect_uri"],
	state: params["state"],
	params: params
	})
	end

	- def create_authorization(conn, %{
	- "authorization" =>
	- %{
	- "client_id" => client_id,
	- "redirect_uri" => redirect_uri
	- } = auth_params
	- }) do
	- with {_, {:ok, %User{} = user}} <- {:get_user, Authenticator.get_user(conn)},
	- %App{} = app <- Repo.get_by(App, client_id: client_id),
	- true <- redirect_uri in String.split(app.redirect_uris),
	- scopes <- oauth_scopes(auth_params, []),
	- {:unsupported_scopes, []} <- {:unsupported_scopes, scopes -- app.scopes},
	- # Note: `scope` param is intentionally not optional in this context
	- {:missing_scopes, false} <- {:missing_scopes, scopes == []},
	- {:auth_active, true} <- {:auth_active, User.auth_active?(user)},
	- {:ok, auth} <- Authorization.create_authorization(app, user, scopes) do
	- redirect_uri = redirect_uri(conn, redirect_uri)
	-
	- cond do
	- redirect_uri == "urn:ietf:wg:oauth:2.0:oob" ->
	- render(conn, "results.html", %{
	- auth: auth
	- })
	-
	- true ->
	- connector = if String.contains?(redirect_uri, "?"), do: "&", else: "?"
	- url = "#{redirect_uri}#{connector}"
	- url_params = %{:code => auth.token}
	-
	- url_params =
	- if auth_params["state"] do
	- Map.put(url_params, :state, auth_params["state"])
	- else
	- url_params
	- end
	+ def create_authorization(
	+ conn,
	+ %{"authorization" => auth_params} = params,
	+ opts \\ []
	+ ) do
	+ with {:ok, auth} <- do_create_authorization(conn, params, opts[:user]) do
	+ after_create_authorization(conn, auth, auth_params)
	+ else
	+ error ->
	+ handle_create_authorization_error(conn, error, auth_params)
	+ end
	+ end

	- url = "#{url}#{Plug.Conn.Query.encode(url_params)}"
	+ def after_create_authorization(conn, auth, %{"redirect_uri" => redirect_uri} = auth_params) do
	+ redirect_uri = redirect_uri(conn, redirect_uri)

	- redirect(conn, external: url)
	- end
	+ if redirect_uri == "urn:ietf:wg:oauth:2.0:oob" do
	+ render(conn, "results.html", %{
	+ auth: auth
	+ })
	else
	- {scopes_issue, _} when scopes_issue in [:unsupported_scopes, :missing_scopes] ->
	- # Per https://github.com/tootsuite/mastodon/blob/
	- # 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L39
	- conn
	- \|> put_flash(:error, "This action is outside the authorized scopes")
	- \|> put_status(:unauthorized)
	- \|> authorize(auth_params)
	+ connector = if String.contains?(redirect_uri, "?"), do: "&", else: "?"
	+ url = "#{redirect_uri}#{connector}"
	+ url_params = %{:code => auth.token}

	- {:auth_active, false} ->
	- # Per https://github.com/tootsuite/mastodon/blob/
	- # 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L76
	- conn
	- \|> put_flash(:error, "Your login is missing a confirmed e-mail address")
	- \|> put_status(:forbidden)
	- \|> authorize(auth_params)
	+ url_params =
	+ if auth_params["state"] do
	+ Map.put(url_params, :state, auth_params["state"])
	+ else
	+ url_params
	+ end

	- error ->
	- Authenticator.handle_error(conn, error)
	+ url = "#{url}#{Plug.Conn.Query.encode(url_params)}"
	+
	+ redirect(conn, external: url)
	end
	end

	+ defp handle_create_authorization_error(conn, {scopes_issue, _}, auth_params)
	+ when scopes_issue in [:unsupported_scopes, :missing_scopes] do
	+ # Per https://github.com/tootsuite/mastodon/blob/
	+ # 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L39
	+ conn
	+ \|> put_flash(:error, "This action is outside the authorized scopes")
	+ \|> put_status(:unauthorized)
	+ \|> authorize(auth_params)
	+ end
	+
	+ defp handle_create_authorization_error(conn, {:auth_active, false}, auth_params) do
	+ # Per https://github.com/tootsuite/mastodon/blob/
	+ # 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L76
	+ conn
	+ \|> put_flash(:error, "Your login is missing a confirmed e-mail address")
	+ \|> put_status(:forbidden)
	+ \|> authorize(auth_params)
	+ end
	+
	+ defp handle_create_authorization_error(conn, error, _auth_params) do
	+ Authenticator.handle_error(conn, error)
	+ end
	+
	def token_exchange(conn, %{"grant_type" => "authorization_code"} = params) do
	with %App{} = app <- get_app_from_request(conn, params),
	fixed_token = fix_padding(params["code"]),
	%Authorization{} = auth <-
	Repo.get_by(Authorization, token: fixed_token, app_id: app.id),
	%User{} = user <- User.get_by_id(auth.user_id),
	{:ok, token} <- Token.exchange_token(app, auth),
	{:ok, inserted_at} <- DateTime.from_naive(token.inserted_at, "Etc/UTC") do
	response = build_response(user, token, %{created_at: DateTime.to_unix(inserted_at)})

	json(conn, response)
	else
	_error ->
	put_status(conn, 400)
	\|> json(%{error: "Invalid credentials"})
	end
	end

	# Replaces `name` param on `username` and perform token_exchange.
	#
	def token_exchange(
	conn,
	%{"grant_type" => "password", "name" => name, "password" => _password} = params
	) do
	params =
	params
	\|> Map.delete("name")
	\|> Map.put("username", name)

	token_exchange(conn, params)
	end

	# Authenticate by username\login with otp token.
	# Second step multi factor authentication
	#
	def token_exchange(conn, %{"grant_type" => "password", "otp_token" => _} = params) do
	- with {:ok, %User{} = user} <- Authenticator.get_user(conn),
	+ with {:ok, %User{} = user} <- Authenticator.get_user(conn, params),
	{_, {:ok, _}} <- {:verify_mfa, TOTPAuthenticator.verify(conn, user)} do
	token_exchange(conn, user, params)
	else
	{:verify_mfa, _res} ->
	{:error, :verify_2fa_failded}

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

	# Authenticate by username\login
	# and add 'required_otp' param to response if user enabled MFA.
	#
	def token_exchange(conn, %{"grant_type" => "password"} = params) do
	- with {:ok, %User{} = user} <- Authenticator.get_user(conn),
	+ with {:ok, %User{} = user} <- Authenticator.get_user(conn, params),
	{_, false} <- {:mfa_required, User.mfa_required?(user)} do
	token_exchange(conn, user, params)
	else
	{:mfa_required, true} ->
	# 2FA enabled for the user and we need to go to 2fa step
	json(conn, Map.merge(params, %{"required_otp" => true}))

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

	# Checks confirmed user and returns token
	#
	defp token_exchange(conn, %User{} = user, %{"grant_type" => "password"} = params) do
	with {:auth_active, true} <- {:auth_active, User.auth_active?(user)},
	{:user_active, true} <- {:user_active, !user.info.deactivated},
	%App{} = app <- get_app_from_request(conn, params),
	{:ok, scopes} <- verify_user_scopes(app, params),
	{:ok, auth} <- Authorization.create_authorization(app, user, scopes),
	{:ok, token} <- Token.exchange_token(app, auth) do
	json(conn, build_response(user, token))
	else
	{:auth_active, false} ->
	# Per https://github.com/tootsuite/mastodon/blob/
	# 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L76
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: "Your login is missing a confirmed e-mail address"})

	{:user_active, false} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: "Your account is currently disabled"})

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

	defp build_response(%User{} = user, token, opts \\ %{}) do
	%{
	token_type: "Bearer",
	access_token: token.token,
	refresh_token: token.refresh_token,
	expires_in: 60 * 10,
	scope: Enum.join(token.scopes, " "),
	me: user.ap_id
	}
	\|> Map.merge(opts)
	end

	def token_revoke(conn, %{"token" => token} = params) do
	with %App{} = app <- get_app_from_request(conn, params),
	%Token{} = token <- Repo.get_by(Token, token: token, app_id: app.id),
	{:ok, %Token{}} <- Repo.delete(token) do
	json(conn, %{})
	else
	_error ->
	# RFC 7009: invalid tokens [in the request] do not cause an error response
	json(conn, %{})
	end
	end

	+ @doc "Prepares OAuth request to provider for Ueberauth"
	+ def prepare_request(conn, %{"provider" => provider} = params) do
	+ scope =
	+ oauth_scopes(params, [])
	+ \|> Enum.join(" ")
	+
	+ state =
	+ params
	+ \|> Map.delete("scopes")
	+ \|> Map.put("scope", scope)
	+ \|> Poison.encode!()
	+
	+ params =
	+ params
	+ \|> Map.drop(~w(scope scopes client_id redirect_uri))
	+ \|> Map.put("state", state)
	+
	+ # Handing the request to Ueberauth
	+ redirect(conn, to: o_auth_path(conn, :request, provider, params))
	+ end
	+
	+ def request(conn, params) do
	+ message =
	+ if params["provider"] do
	+ "Unsupported OAuth provider: #{params["provider"]}."
	+ else
	+ "Bad OAuth request."
	+ end
	+
	+ conn
	+ \|> put_flash(:error, message)
	+ \|> redirect(to: "/")
	+ end
	+
	+ def callback(%{assigns: %{ueberauth_failure: failure}} = conn, params) do
	+ params = callback_params(params)
	+ messages = for e <- Map.get(failure, :errors, []), do: e.message
	+ message = Enum.join(messages, "; ")
	+
	+ conn
	+ \|> put_flash(:error, "Failed to authenticate: #{message}.")
	+ \|> redirect(external: redirect_uri(conn, params["redirect_uri"]))
	+ end
	+
	+ def callback(conn, params) do
	+ params = callback_params(params)
	+
	+ with {:ok, registration} <- Authenticator.get_registration(conn, params) do
	+ user = Repo.preload(registration, :user).user
	+ auth_params = Map.take(params, ~w(client_id redirect_uri scope scopes state))
	+
	+ if user do
	+ create_authorization(
	+ conn,
	+ %{"authorization" => auth_params},
	+ user: user
	+ )
	+ else
	+ registration_params =
	+ Map.merge(auth_params, %{
	+ "nickname" => Registration.nickname(registration),
	+ "email" => Registration.email(registration)
	+ })
	+
	+ conn
	+ \|> put_session(:registration_id, registration.id)
	+ \|> registration_details(registration_params)
	+ end
	+ else
	+ _ ->
	+ conn
	+ \|> put_flash(:error, "Failed to set up user account.")
	+ \|> redirect(external: redirect_uri(conn, params["redirect_uri"]))
	+ end
	+ end
	+
	+ defp callback_params(%{"state" => state} = params) do
	+ Map.merge(params, Poison.decode!(state))
	+ end
	+
	+ def registration_details(conn, params) do
	+ render(conn, "register.html", %{
	+ client_id: params["client_id"],
	+ redirect_uri: params["redirect_uri"],
	+ state: params["state"],
	+ scopes: oauth_scopes(params, []),
	+ nickname: params["nickname"],
	+ email: params["email"]
	+ })
	+ end
	+
	+ def register(conn, %{"op" => "connect"} = params) do
	+ authorization_params = Map.put(params, "name", params["auth_name"])
	+ create_authorization_params = %{"authorization" => authorization_params}
	+
	+ with registration_id when not is_nil(registration_id) <- get_session_registration_id(conn),
	+ %Registration{} = registration <- Repo.get(Registration, registration_id),
	+ {_, {:ok, auth}} <-
	+ {:create_authorization, do_create_authorization(conn, create_authorization_params)},
	+ %User{} = user <- Repo.preload(auth, :user).user,
	+ {:ok, _updated_registration} <- Registration.bind_to_user(registration, user) do
	+ conn
	+ \|> put_session_registration_id(nil)
	+ \|> after_create_authorization(auth, authorization_params)
	+ else
	+ {:create_authorization, error} ->
	+ {:register, handle_create_authorization_error(conn, error, create_authorization_params)}
	+
	+ _ ->
	+ {:register, :generic_error}
	+ end
	+ end
	+
	+ def register(conn, %{"op" => "register"} = params) do
	+ with registration_id when not is_nil(registration_id) <- get_session_registration_id(conn),
	+ %Registration{} = registration <- Repo.get(Registration, registration_id),
	+ {:ok, user} <- Authenticator.create_from_registration(conn, params, registration) do
	+ conn
	+ \|> put_session_registration_id(nil)
	+ \|> create_authorization(
	+ %{
	+ "authorization" => %{
	+ "client_id" => params["client_id"],
	+ "redirect_uri" => params["redirect_uri"],
	+ "scopes" => oauth_scopes(params, nil)
	+ }
	+ },
	+ user: user
	+ )
	+ else
	+ {:error, changeset} ->
	+ message =
	+ Enum.map(changeset.errors, fn {field, {error, _}} ->
	+ "#{field} #{error}"
	+ end)
	+ \|> Enum.join("; ")
	+
	+ message =
	+ String.replace(
	+ message,
	+ "ap_id has already been taken",
	+ "nickname has already been taken"
	+ )
	+
	+ conn
	+ \|> put_status(:forbidden)
	+ \|> put_flash(:error, "Error: #{message}.")
	+ \|> registration_details(params)
	+
	+ _ ->
	+ {:register, :generic_error}
	+ end
	+ end
	+
	+ defp do_create_authorization(
	+ conn,
	+ %{
	+ "authorization" =>
	+ %{
	+ "client_id" => client_id,
	+ "redirect_uri" => redirect_uri
	+ } = auth_params
	+ } = params,
	+ user \\ nil
	+ ) do
	+ with {_, {:ok, %User{} = user}} <-
	+ {:get_user, (user && {:ok, user}) \|\| Authenticator.get_user(conn, params)},
	+ %App{} = app <- Repo.get_by(App, client_id: client_id),
	+ true <- redirect_uri in String.split(app.redirect_uris),
	+ scopes <- oauth_scopes(auth_params, []),
	+ {:unsupported_scopes, []} <- {:unsupported_scopes, scopes -- app.scopes},
	+ # Note: `scope` param is intentionally not optional in this context
	+ {:missing_scopes, false} <- {:missing_scopes, scopes == []},
	+ {:auth_active, true} <- {:auth_active, User.auth_active?(user)} do
	+ Authorization.create_authorization(app, user, scopes)
	+ end
	+ end
	+
	# XXX - for whatever reason our token arrives urlencoded, but Plug.Conn should be
	# decoding it. Investigate sometime.
	defp fix_padding(token) do
	token
	\|> URI.decode()
	\|> Base.url_decode64!(padding: false)
	\|> Base.url_encode64(padding: false)
	end

	defp get_app_from_request(conn, params) do
	# Per RFC 6749, HTTP Basic is preferred to body params
	{client_id, client_secret} =
	with ["Basic " <> encoded] <- get_req_header(conn, "authorization"),
	{:ok, decoded} <- Base.decode64(encoded),
	[id, secret] <-
	String.split(decoded, ":")
	\|> Enum.map(fn s -> URI.decode_www_form(s) end) do
	{id, secret}
	else
	_ -> {params["client_id"], params["client_secret"]}
	end

	if client_id && client_secret do
	Repo.get_by(
	App,
	client_id: client_id,
	client_secret: client_secret
	)
	else
	nil
	end
	end

	# Special case: Local MastodonFE
	defp redirect_uri(conn, "."), do: mastodon_api_url(conn, :login)

	defp redirect_uri(_conn, redirect_uri), do: redirect_uri

	+ defp get_session_registration_id(conn), do: get_session(conn, :registration_id)
	+
	+ defp put_session_registration_id(conn, registration_id),
	+ do: put_session(conn, :registration_id, registration_id)
	+
	defp verify_user_scopes(app, params) do
	with scopes <- oauth_scopes(params, app.scopes),
	{:unsupported, []} <- {:unsupported, scopes -- app.scopes},
	{:missing, true} <- {:missing, Enum.any?(scopes)} do
	{:ok, scopes}
	else
	{scopes_issue, _} when scopes_issue in [:unsupported, :missing] ->
	{:error, scopes_issue}

	_ ->
	{:error, :unverify}
	end
	end
	end
	diff --git a/lib/pleroma/web/push/impl.ex b/lib/pleroma/web/push/impl.ex
	index 863573185..2233480c5 100644
	--- a/lib/pleroma/web/push/impl.ex
	+++ b/lib/pleroma/web/push/impl.ex
	@@ -1,133 +1,133 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.Impl do
	@moduledoc "The module represents implementation push web notification"

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.Metadata.Utils
	alias Pleroma.Web.Push.Subscription

	require Logger
	import Ecto.Query

	@types ["Create", "Follow", "Announce", "Like"]

	@doc "Performs sending notifications for user subscriptions"
	- @spec perform_send(Notification.t()) :: list(any)
	- def perform_send(
	+ @spec perform(Notification.t()) :: list(any) \| :error
	+ def perform(
	%{activity: %{data: %{"type" => activity_type}, id: activity_id}, user_id: user_id} =
	notif
	)
	when activity_type in @types do
	actor = User.get_cached_by_ap_id(notif.activity.data["actor"])

	type = Activity.mastodon_notification_type(notif.activity)
	gcm_api_key = Application.get_env(:web_push_encryption, :gcm_api_key)
	avatar_url = User.avatar_url(actor)

	for subscription <- fetch_subsriptions(user_id),
	get_in(subscription.data, ["alerts", type]) do
	%{
	title: format_title(notif),
	access_token: subscription.token.token,
	body: format_body(notif, actor),
	notification_id: notif.id,
	notification_type: type,
	icon: avatar_url,
	preferred_locale: "en",
	pleroma: %{
	activity_id: activity_id
	}
	}
	\|> Jason.encode!()
	\|> push_message(build_sub(subscription), gcm_api_key, subscription)
	end
	end

	- def perform_send(_) do
	+ def perform(_) do
	Logger.warn("Unknown notification type")
	:error
	end

	@doc "Push message to web"
	def push_message(body, sub, api_key, subscription) do
	case WebPushEncryption.send_web_push(body, sub, api_key) do
	{:ok, %{status_code: code}} when 400 <= code and code < 500 ->
	Logger.debug("Removing subscription record")
	Repo.delete!(subscription)
	:ok

	{:ok, %{status_code: code}} when 200 <= code and code < 300 ->
	:ok

	{:ok, %{status_code: code}} ->
	Logger.error("Web Push Notification failed with code: #{code}")
	:error

	_ ->
	Logger.error("Web Push Notification failed with unknown error")
	:error
	end
	end

	@doc "Gets user subscriptions"
	def fetch_subsriptions(user_id) do
	Subscription
	\|> where(user_id: ^user_id)
	\|> preload(:token)
	\|> Repo.all()
	end

	def build_sub(subscription) do
	%{
	keys: %{
	p256dh: subscription.key_p256dh,
	auth: subscription.key_auth
	},
	endpoint: subscription.endpoint
	}
	end

	def format_body(
	%{activity: %{data: %{"type" => "Create", "object" => %{"content" => content}}}},
	actor
	) do
	"@#{actor.nickname}: #{Utils.scrub_html_and_truncate(content, 80)}"
	end

	def format_body(
	%{activity: %{data: %{"type" => "Announce", "object" => activity_id}}},
	actor
	) do
	%Activity{data: %{"object" => %{"id" => object_id}}} = Activity.get_by_ap_id(activity_id)
	%Object{data: %{"content" => content}} = Object.get_by_ap_id(object_id)

	"@#{actor.nickname} repeated: #{Utils.scrub_html_and_truncate(content, 80)}"
	end

	def format_body(
	%{activity: %{data: %{"type" => type}}},
	actor
	)
	when type in ["Follow", "Like"] do
	case type do
	"Follow" -> "@#{actor.nickname} has followed you"
	"Like" -> "@#{actor.nickname} has favorited your post"
	end
	end

	def format_title(%{activity: %{data: %{"type" => type}}}) do
	case type do
	"Create" -> "New Mention"
	"Follow" -> "New Follower"
	"Announce" -> "New Repeat"
	"Like" -> "New Favorite"
	end
	end
	end
	diff --git a/lib/pleroma/web/push/push.ex b/lib/pleroma/web/push/push.ex
	index 5259e8e33..729dad02a 100644
	--- a/lib/pleroma/web/push/push.ex
	+++ b/lib/pleroma/web/push/push.ex
	@@ -1,64 +1,36 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push do
	- use GenServer
	-
	alias Pleroma.Web.Push.Impl

	require Logger

	- ##############
	- # Client API #
	- ##############
	+ def init do
	+ unless enabled() do
	+ Logger.warn("""
	+ VAPID key pair is not found. If you wish to enabled web push, please run
	+
	+ mix web_push.gen.keypair

	- def start_link do
	- GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
	+ and add the resulting output to your configuration file.
	+ """)
	+ end
	end

	def vapid_config do
	Application.get_env(:web_push_encryption, :vapid_details, [])
	end

	def enabled do
	case vapid_config() do
	[] -> false
	list when is_list(list) -> true
	_ -> false
	end
	end

	def send(notification),
	- do: GenServer.cast(__MODULE__, {:send, notification})
	-
	- ####################
	- # Server Callbacks #
	- ####################
	-
	- @impl true
	- def init(:ok) do
	- if enabled() do
	- {:ok, nil}
	- else
	- Logger.warn("""
	- VAPID key pair is not found. If you wish to enabled web push, please run
	-
	- mix web_push.gen.keypair
	-
	- and add the resulting output to your configuration file.
	- """)
	-
	- :ignore
	- end
	- end
	-
	- @impl true
	- def handle_cast({:send, notification}, state) do
	- if enabled() do
	- Impl.perform_send(notification)
	- end
	-
	- {:noreply, state}
	- end
	+ do: PleromaJobQueue.enqueue(:web_push, Impl, [notification])
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index f02fdaad5..7b4b6a46e 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,705 +1,720 @@
	# 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_unauthenticated do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{
	scopes: ["read"],
	fallback: :proceed_unauthenticated
	})
	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)
	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("/user/follow", AdminAPIController, :user_follow)
	post("/user/unfollow", AdminAPIController, :user_unfollow)

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

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

	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)

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

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

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

	get("/password_reset", AdminAPIController, :get_password_reset)
	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)
	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

	post("/2fa/disable", TwoFactorAuthenticationController, :disable)
	get("/2fa/provisioning_uri", TwoFactorAuthenticationController, :provisioning_uri)
	post("/2fa/enable", TwoFactorAuthenticationController, :enable)
	get("/2fa/backup_codes", TwoFactorAuthenticationController, :backup_codes)
	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/search", MastodonAPIController, :account_search)

	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)

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

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

	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)

	scope [] do
	pipe_through(:oauth_read_or_unauthenticated)

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

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through([:api, :oauth_read_or_unauthenticated])
	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_unauthenticated)

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

	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_unauthenticated])
	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_unauthenticated)
	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 "/", Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	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 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/templates/o_auth/o_auth/_scopes.html.eex b/lib/pleroma/web/templates/o_auth/o_auth/_scopes.html.eex
	new file mode 100644
	index 000000000..4b8fb5dae
	--- /dev/null
	+++ b/lib/pleroma/web/templates/o_auth/o_auth/_scopes.html.eex
	@@ -0,0 +1,13 @@
	+<div class="scopes-input">
	+ <%= label @form, :scope, "Permissions" %>
	+
	+ <div class="scopes">
	+ <%= for scope <- @available_scopes do %>
	+ <%# Note: using hidden input with `unchecked_value` in order to distinguish user's empty selection from `scope` param being omitted %>
	+ <div class="scope">
	+ <%= checkbox @form, :"scope_#{scope}", value: scope in @scopes && scope, checked_value: scope, unchecked_value: "", name: assigns[:scope_param] \|\| "scope[]" %>
	+ <%= label @form, :"scope_#{scope}", String.capitalize(scope) %>
	+ </div>
	+ <% end %>
	+ </div>
	+</div>
	diff --git a/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex b/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex
	new file mode 100644
	index 000000000..85f62ca64
	--- /dev/null
	+++ b/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex
	@@ -0,0 +1,13 @@
	+<h2>Sign in with external provider</h2>
	+
	+<%= form_for @conn, o_auth_path(@conn, :prepare_request), [method: "get"], fn f -> %>
	+ <%= render @view_module, "_scopes.html", Map.put(assigns, :form, f) %>
	+
	+ <%= hidden_input f, :client_id, value: @client_id %>
	+ <%= hidden_input f, :redirect_uri, value: @redirect_uri %>
	+ <%= hidden_input f, :state, value: @state %>
	+
	+ <%= for strategy <- Pleroma.Config.oauth_consumer_strategies() do %>
	+ <%= submit "Sign in with #{String.capitalize(strategy)}", name: "provider", value: strategy %>
	+ <% end %>
	+<% end %>
	diff --git a/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex b/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex
	new file mode 100644
	index 000000000..126390391
	--- /dev/null
	+++ b/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex
	@@ -0,0 +1,43 @@
	+<%= if get_flash(@conn, :info) do %>
	+ <p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
	+<% end %>
	+<%= if get_flash(@conn, :error) do %>
	+ <p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
	+<% end %>
	+
	+<h2>Registration Details</h2>
	+
	+<p>If you'd like to register a new account, please provide the details below.</p>
	+
	+<%= form_for @conn, o_auth_path(@conn, :register), [], fn f -> %>
	+
	+<div class="input">
	+ <%= label f, :nickname, "Nickname" %>
	+ <%= text_input f, :nickname, value: @nickname %>
	+</div>
	+<div class="input">
	+ <%= label f, :email, "Email" %>
	+ <%= text_input f, :email, value: @email %>
	+</div>
	+
	+<%= submit "Proceed as new user", name: "op", value: "register" %>
	+
	+<p>Alternatively, sign in to connect to existing account.</p>
	+
	+<div class="input">
	+ <%= label f, :auth_name, "Name or email" %>
	+ <%= text_input f, :auth_name %>
	+</div>
	+<div class="input">
	+ <%= label f, :password, "Password" %>
	+ <%= password_input f, :password %>
	+</div>
	+
	+<%= submit "Proceed as existing user", name: "op", value: "connect" %>
	+
	+<%= hidden_input f, :client_id, value: @client_id %>
	+<%= hidden_input f, :redirect_uri, value: @redirect_uri %>
	+<%= hidden_input f, :scope, value: Enum.join(@scopes, " ") %>
	+<%= hidden_input f, :state, value: @state %>
	+
	+<% end %>
	diff --git a/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex b/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex
	index 161333847..87278e636 100644
	--- a/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex
	+++ b/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex
	@@ -1,35 +1,31 @@
	<%= if get_flash(@conn, :info) do %>
	<p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
	<% end %>
	<%= if get_flash(@conn, :error) do %>
	<p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
	<% end %>
	+
	<h2>OAuth Authorization</h2>
	+
	<%= form_for @conn, o_auth_path(@conn, :authorize), [as: "authorization"], fn f -> %>
	<div class="input">
	<%= label f, :name, "Name or email" %>
	<%= text_input f, :name %>
	</div>
	<div class="input">
	<%= label f, :password, "Password" %>
	<%= password_input f, :password %>
	</div>
	-<div class="scopes-input">
	-<%= label f, :scope, "Permissions" %>
	- <div class="scopes">
	- <%= for scope <- @available_scopes do %>
	- <%# Note: using hidden input with `unchecked_value` in order to distinguish user's empty selection from `scope` param being omitted %>
	- <div class="scope">
	- <%= checkbox f, :"scope_#{scope}", value: scope in @scopes && scope, checked_value: scope, unchecked_value: "", name: "authorization[scope][]" %>
	- <%= label f, :"scope_#{scope}", String.capitalize(scope) %>
	- </div>
	- <% end %>
	- </div>
	-</div>
	+
	+<%= render @view_module, "_scopes.html", Map.merge(assigns, %{form: f, scope_param: "authorization[scope][]"}) %>

	<%= hidden_input f, :client_id, value: @client_id %>
	<%= hidden_input f, :response_type, value: @response_type %>
	<%= hidden_input f, :redirect_uri, value: @redirect_uri %>
	-<%= hidden_input f, :state, value: @state%>
	+<%= hidden_input f, :state, value: @state %>
	<%= submit "Authorize" %>
	<% end %>
	+
	+<%= if Pleroma.Config.oauth_consumer_enabled?() do %>
	+ <%= render @view_module, Pleroma.Web.Auth.Authenticator.oauth_consumer_template(), assigns %>
	+<% end %>
	diff --git a/lib/pleroma/web/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index aa69bf687..829fad769 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,347 +1,353 @@
	# 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.UtilController do
	use Pleroma.Web, :controller

	require Logger

	alias Comeonin.Pbkdf2
	alias Pleroma.Activity
	alias Pleroma.Emoji
	alias Pleroma.Notification
	alias Pleroma.PasswordResetToken
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.WebFinger

	def show_password_reset(conn, %{"token" => token}) do
	with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
	%User{} = user <- User.get_by_id(token.user_id) do
	render(conn, "password_reset.html", %{
	token: token,
	user: user
	})
	else
	_e -> render(conn, "invalid_token.html")
	end
	end

	def password_reset(conn, %{"data" => data}) do
	with {:ok, _} <- PasswordResetToken.reset_password(data["token"], data) do
	render(conn, "password_reset_success.html")
	else
	_e -> render(conn, "password_reset_failed.html")
	end
	end

	def help_test(conn, _params) do
	json(conn, "ok")
	end

	def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
	with %User{} = user <- User.get_cached_by_nickname(nick), avatar = User.avatar_url(user) do
	conn
	\|> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error: "Could not find user"
	})
	end
	end

	def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error: "Something went wrong."
	})
	end
	end

	def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
	if is_status?(acct) do
	{:ok, object} = ActivityPub.fetch_object_from_id(acct)
	%Activity{id: activity_id} = Activity.get_create_by_object_ap_id(object.data["id"])
	redirect(conn, to: "/notice/#{activity_id}")
	else
	{err, followee} = OStatus.find_or_make_user(acct)
	avatar = User.avatar_url(followee)
	name = followee.nickname
	id = followee.id

	if !!user do
	conn
	\|> render("follow.html", %{error: err, acct: acct, avatar: avatar, name: name, id: id})
	else
	conn
	\|> render("follow_login.html", %{
	error: false,
	acct: acct,
	avatar: avatar,
	name: name,
	id: id
	})
	end
	end
	end

	defp is_status?(acct) do
	case ActivityPub.fetch_and_contain_remote_object_from_id(acct) do
	{:ok, %{"type" => type}} when type in ["Article", "Note", "Video", "Page", "Question"] ->
	true

	_ ->
	false
	end
	end

	def do_remote_follow(conn, %{
	"authorization" => %{"name" => username, "password" => password, "id" => id}
	}) do
	followee = User.get_by_id(id)
	avatar = User.avatar_url(followee)
	name = followee.nickname

	with %User{} = user <- User.get_cached_by_nickname(username),
	true <- Pbkdf2.checkpw(password, user.password_hash),
	%User{} = _followed <- User.get_by_id(id),
	{:ok, follower} <- User.follow(user, followee),
	{:ok, _activity} <- ActivityPub.follow(follower, followee) do
	conn
	\|> render("followed.html", %{error: false})
	else
	# Was already following user
	{:error, "Could not follow user:" <> _rest} ->
	render(conn, "followed.html", %{error: false})

	_e ->
	conn
	\|> render("follow_login.html", %{
	error: "Wrong username or password",
	id: id,
	name: name,
	avatar: avatar
	})
	end
	end

	def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
	with %User{} = followee <- User.get_by_id(id),
	{:ok, follower} <- User.follow(user, followee),
	{:ok, _activity} <- ActivityPub.follow(follower, followee) do
	conn
	\|> render("followed.html", %{error: false})
	else
	# Was already following user
	{:error, "Could not follow user:" <> _rest} ->
	conn
	\|> render("followed.html", %{error: false})

	e ->
	Logger.debug("Remote follow failed with error #{inspect(e)}")

	conn
	\|> render("followed.html", %{error: inspect(e)})
	end
	end

	def notifications_read(%{assigns: %{user: user}} = conn, %{"id" => notification_id}) do
	with {:ok, _} <- Notification.read_one(user, notification_id) do
	json(conn, %{status: "success"})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def config(conn, _params) do
	instance = Pleroma.Config.get(:instance)
	instance_fe = Pleroma.Config.get(:fe)
	instance_chat = Pleroma.Config.get(:chat)

	case get_format(conn) do
	"xml" ->
	response = """
	<config>
	<site>
	<name>#{Keyword.get(instance, :name)}</name>
	<site>#{Web.base_url()}</site>
	<textlimit>#{Keyword.get(instance, :limit)}</textlimit>
	<closed>#{!Keyword.get(instance, :registrations_open)}</closed>
	</site>
	</config>
	"""

	conn
	\|> put_resp_content_type("application/xml")
	\|> send_resp(200, response)

	_ ->
	vapid_public_key = Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)

	uploadlimit = %{
	uploadlimit: to_string(Keyword.get(instance, :upload_limit)),
	avatarlimit: to_string(Keyword.get(instance, :avatar_upload_limit)),
	backgroundlimit: to_string(Keyword.get(instance, :background_upload_limit)),
	bannerlimit: to_string(Keyword.get(instance, :banner_upload_limit))
	}

	data = %{
	name: Keyword.get(instance, :name),
	description: Keyword.get(instance, :description),
	server: Web.base_url(),
	textlimit: to_string(Keyword.get(instance, :limit)),
	uploadlimit: uploadlimit,
	closed: if(Keyword.get(instance, :registrations_open), do: "0", else: "1"),
	private: if(Keyword.get(instance, :public, true), do: "0", else: "1"),
	vapidPublicKey: vapid_public_key,
	accountActivationRequired:
	if(Keyword.get(instance, :account_activation_required, false), do: "1", else: "0"),
	invitesEnabled: if(Keyword.get(instance, :invites_enabled, false), do: "1", else: "0"),
	safeDMMentionsEnabled:
	if(Pleroma.Config.get([:instance, :safe_dm_mentions]), do: "1", else: "0")
	}

	pleroma_fe =
	if instance_fe do
	%{
	theme: Keyword.get(instance_fe, :theme),
	background: Keyword.get(instance_fe, :background),
	logo: Keyword.get(instance_fe, :logo),
	logoMask: Keyword.get(instance_fe, :logo_mask),
	logoMargin: Keyword.get(instance_fe, :logo_margin),
	redirectRootNoLogin: Keyword.get(instance_fe, :redirect_root_no_login),
	redirectRootLogin: Keyword.get(instance_fe, :redirect_root_login),
	chatDisabled: !Keyword.get(instance_chat, :enabled),
	showInstanceSpecificPanel: Keyword.get(instance_fe, :show_instance_panel),
	scopeOptionsEnabled: Keyword.get(instance_fe, :scope_options_enabled),
	formattingOptionsEnabled: Keyword.get(instance_fe, :formatting_options_enabled),
	collapseMessageWithSubject:
	Keyword.get(instance_fe, :collapse_message_with_subject),
	hidePostStats: Keyword.get(instance_fe, :hide_post_stats),
	hideUserStats: Keyword.get(instance_fe, :hide_user_stats),
	scopeCopy: Keyword.get(instance_fe, :scope_copy),
	subjectLineBehavior: Keyword.get(instance_fe, :subject_line_behavior),
	alwaysShowSubjectInput: Keyword.get(instance_fe, :always_show_subject_input)
	}
	else
	Pleroma.Config.get([:frontend_configurations, :pleroma_fe])
	end

	managed_config = Keyword.get(instance, :managed_config)

	data =
	if managed_config do
	data \|> Map.put("pleromafe", pleroma_fe)
	else
	data
	end

	json(conn, %{site: data})
	end
	end

	def frontend_configurations(conn, _params) do
	config =
	Pleroma.Config.get(:frontend_configurations, %{})
	\|> Enum.into(%{})

	json(conn, config)
	end

	def version(conn, _params) do
	version = Pleroma.Application.named_version()

	case get_format(conn) do
	"xml" ->
	response = "<version>#{version}</version>"

	conn
	\|> put_resp_content_type("application/xml")
	\|> send_resp(200, response)

	_ ->
	json(conn, version)
	end
	end

	def emoji(conn, _params) do
	- json(conn, Enum.into(Emoji.get_all(), %{}))
	+ emoji =
	+ Emoji.get_all()
	+ \|> Enum.map(fn {short_code, path, tags} ->
	+ %{short_code => %{image_url: path, tags: String.split(tags, ",")}}
	+ end)
	+
	+ json(conn, emoji)
	end

	def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
	follow_import(conn, %{"list" => File.read!(listfile.path)})
	end

	def follow_import(%{assigns: %{user: follower}} = conn, %{"list" => list}) do
	with followed_identifiers <- String.split(list),
	{:ok, _} = Task.start(fn -> User.follow_import(follower, followed_identifiers) end) do
	json(conn, "job started")
	end
	end

	def blocks_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
	blocks_import(conn, %{"list" => File.read!(listfile.path)})
	end

	def blocks_import(%{assigns: %{user: blocker}} = conn, %{"list" => list}) do
	with blocked_identifiers <- String.split(list),
	{:ok, _} = Task.start(fn -> User.blocks_import(blocker, blocked_identifiers) end) do
	json(conn, "job started")
	end
	end

	def change_password(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
	{:ok, user} ->
	with {:ok, _user} <-
	User.reset_password(user, %{
	password: params["new_password"],
	password_confirmation: params["new_password_confirmation"]
	}) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "New password #{error}."})

	_ ->
	json(conn, %{error: "Unable to change password."})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def delete_account(%{assigns: %{user: user}} = conn, params) do
	with {:ok, user} <- CommonAPI.Utils.confirm_current_password(user, params["password"]) do
	Task.start(fn -> User.delete(user) end)
	json(conn, %{status: "success"})
	else
	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def captcha(conn, _params) do
	json(conn, Pleroma.Captcha.new())
	end
	end
	diff --git a/mix.exs b/mix.exs
	index 3da6bf5fb..12e2b80ab 100644
	--- a/mix.exs
	+++ b/mix.exs
	@@ -1,170 +1,178 @@
	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(),

	# Docs
	name: "Pleroma",
	source_url: "https://git.pleroma.social/pleroma/pleroma",
	source_url_pattern:
	"https://git.pleroma.social/pleroma/pleroma/blob/develop/%{path}#L%{line}",
	homepage_url: "https://pleroma.social/",
	docs: [
	logo: "priv/static/static/logo.png",
	extras: ["README.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, :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, "~>3.0.5"},
	{: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"},
	{:ex_machina, "~> 2.3", only: :test},
	{:credo, "~> 0.9.3", only: [:dev, :test]},
	{:mock, "~> 0.3.1", only: :test},
	{:crypt,
	git: "https://github.com/msantos/crypt", ref: "1f2b58927ab57e72910191a7ebaeff984382a1d3"},
	{:cors_plug, "~> 1.5"},
	{:ex_doc, "~> 0.19", 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: "479dd343f4e563ff91215c8275f3b5c67e032850"},
	{: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"},
	{:pot, "~> 0.9.7"}
	- ]
	+ ] ++ 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 2643f0e02..72ca1ac64 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,83 +1,84 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm"},
	"auto_linker": {:git, "https://git.pleroma.social/pleroma/auto_linker.git", "479dd343f4e563ff91215c8275f3b5c67e032850", [ref: "479dd343f4e563ff91215c8275f3b5c67e032850"]},
	"base64url": {:hex, :base64url, "0.0.1", "36a90125f5948e3afd7be97662a1504b934dd5dac78451ca6e9abf85a10286be", [:rebar], [], "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.4.2", "75424ff0f3baaccfd34b1214184b6ef616d89e420b258bb0a5ea7d7bc628f7f0", [:rebar3], [{:parse_trans, "~>3.3", [hex: :parse_trans, 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.5", "ddb2ba6761a08b2bb9ca0e7d260e8f4dd39067426d835c24491a321b7f92a4da", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"},
	"decimal": {:hex, :decimal, "1.7.0", "30d6b52c88541f9a66637359ddf85016df9eb266170d53105f02e4a67e00c5aa", [:mix], [], "hexpm"},
	"earmark": {:hex, :earmark, "1.3.0", "17f0c38eaafb4800f746b457313af4b2442a8c2405b49c645768680f900be603", [:mix], [], "hexpm"},
	"ecto": {:hex, :ecto, "3.0.7", "44dda84ac6b17bbbdeb8ac5dfef08b7da253b37a453c34ab1a98de7f7e5fec7f", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}], "hexpm"},
	"ecto_sql": {:hex, :ecto_sql, "3.0.5", "7e44172b4f7aca4469f38d7f6a3da394dbf43a1bcf0ca975e958cb957becd74e", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.0.6", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.3.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
	"eternal": {:hex, :eternal, "1.2.0", "e2a6b6ce3b8c248f7dc31451aefca57e3bdf0e48d73ae5043229380a67614c41", [: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.19.1", "519bb9c19526ca51d326c060cb1778d4a9056b190086a8c6c115828eaccea6cf", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.7", [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_syslogger": {:git, "https://github.com/slashmili/ex_syslogger.git", "f3963399047af17e038897c69e20d552e6899e1d", [tag: "1.4.0"]},
	"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.14.3", "b5f6f5dcc4f1fba340762738759209e21914516df6be440d85772542d4a5e412", [:rebar3], [{:certifi, "2.4.2", [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.0.2", [hex: :mimerl, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "1.1.4", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "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"},
	"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.5.5", "9e08dfc45280c5684d771ad58159f718a7b5788596099bdfb0284597d368a882", [:mix], [{:nimble_parsec, "~> 0.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.10.0", "0f09c2ddf352887a956d84f8f7e702111122ca32fbbc84c2f0569b8b65cbf7fa", [:mix], [{:makeup, "~> 0.5.5", [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.0.2", "993f9b0e084083405ed8252b99460c4f0563e41729ab42d9074fd5e52439be88", [:rebar3], [], "hexpm"},
	+ "mimerl": {:hex, :mimerl, "1.2.0", "67e2d3f571088d5cfd3e550c383094b47159f3eee8ffa08e64106cdf5e981be3", [:rebar3], [], "hexpm"},
	"mochiweb": {:hex, :mochiweb, "2.15.0", "e1daac474df07651e5d17cc1e642c4069c7850dc4508d3db7263a0651330aacc", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.1", "994f00150f79a0ea50dc9d86134cd9ebd0d177ad60bd04d1e46336cdfdb98ff9", [:mix], [{:meck, "~> 0.8.8", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm"},
	"mogrify": {:hex, :mogrify, "0.6.1", "de1b527514f2d95a7bbe9642eb556061afb337e220cf97adbf3a4e6438ed70af", [:mix], [], "hexpm"},
	"nimble_parsec": {:hex, :nimble_parsec, "0.4.0", "ee261bb53214943679422be70f1658fff573c5d0b0a1ecd0f18738944f818efe", [: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"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm"},
	"poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm"},
	"postgrex": {:hex, :postgrex, "0.14.1", "63247d4a5ad6b9de57a0bac5d807e1c32d41e39c04b8a4156a26c63bcd8a2e49", [: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"},
	"pot": {:hex, :pot, "0.9.7", "11b33c1ef47e000ffc2027f12f623371897efb8a5755abcc67bcd30e984901c4", [:rebar3], [], "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.3.0", "099a7f3ce31e4780f971b4630a3c22ec66d22208bc090fe33a2a3a6a67754a73", [: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.17", "50793e3d85af49736701da1a040c415c97dc1caf6464112fd9bd18f425d3053b", [: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/priv/repo/migrations/20190315101315_create_registrations.exs b/priv/repo/migrations/20190315101315_create_registrations.exs
	new file mode 100644
	index 000000000..6b28cbdd3
	--- /dev/null
	+++ b/priv/repo/migrations/20190315101315_create_registrations.exs
	@@ -0,0 +1,18 @@
	+defmodule Pleroma.Repo.Migrations.CreateRegistrations do
	+ use Ecto.Migration
	+
	+ def change do
	+ create table(:registrations, primary_key: false) do
	+ add :id, :uuid, primary_key: true
	+ add :user_id, references(:users, type: :uuid, on_delete: :delete_all)
	+ add :provider, :string
	+ add :uid, :string
	+ add :info, :map, default: %{}
	+
	+ timestamps()
	+ end
	+
	+ create unique_index(:registrations, [:provider, :uid])
	+ create unique_index(:registrations, [:user_id, :provider, :uid])
	+ end
	+end
	diff --git a/test/emoji_test.exs b/test/emoji_test.exs
	new file mode 100644
	index 000000000..cb1d62d00
	--- /dev/null
	+++ b/test/emoji_test.exs
	@@ -0,0 +1,106 @@
	+defmodule Pleroma.EmojiTest do
	+ use ExUnit.Case, async: true
	+ alias Pleroma.Emoji
	+
	+ describe "get_all/0" do
	+ setup do
	+ emoji_list = Emoji.get_all()
	+ {:ok, emoji_list: emoji_list}
	+ end
	+
	+ test "first emoji", %{emoji_list: emoji_list} do
	+ [emoji \| _others] = emoji_list
	+ {code, path, tags} = emoji
	+
	+ assert tuple_size(emoji) == 3
	+ assert is_binary(code)
	+ assert is_binary(path)
	+ assert is_binary(tags)
	+ end
	+
	+ test "random emoji", %{emoji_list: emoji_list} do
	+ emoji = Enum.random(emoji_list)
	+ {code, path, tags} = emoji
	+
	+ assert tuple_size(emoji) == 3
	+ assert is_binary(code)
	+ assert is_binary(path)
	+ assert is_binary(tags)
	+ end
	+ end
	+
	+ describe "match_extra/2" do
	+ setup do
	+ groups = [
	+ "list of files": ["/emoji/custom/first_file.png", "/emoji/custom/second_file.png"],
	+ "wildcard folder": "/emoji/custom/*/file.png",
	+ "wildcard files": "/emoji/custom/folder/*.png",
	+ "special file": "/emoji/custom/special.png"
	+ ]
	+
	+ {:ok, groups: groups}
	+ end
	+
	+ test "config for list of files", %{groups: groups} do
	+ group =
	+ groups
	+ \|> Emoji.match_extra("/emoji/custom/first_file.png")
	+ \|> to_string()
	+
	+ assert group == "list of files"
	+ end
	+
	+ test "config with wildcard folder", %{groups: groups} do
	+ group =
	+ groups
	+ \|> Emoji.match_extra("/emoji/custom/some_folder/file.png")
	+ \|> to_string()
	+
	+ assert group == "wildcard folder"
	+ end
	+
	+ test "config with wildcard folder and subfolders", %{groups: groups} do
	+ group =
	+ groups
	+ \|> Emoji.match_extra("/emoji/custom/some_folder/another_folder/file.png")
	+ \|> to_string()
	+
	+ assert group == "wildcard folder"
	+ end
	+
	+ test "config with wildcard files", %{groups: groups} do
	+ group =
	+ groups
	+ \|> Emoji.match_extra("/emoji/custom/folder/some_file.png")
	+ \|> to_string()
	+
	+ assert group == "wildcard files"
	+ end
	+
	+ test "config with wildcard files and subfolders", %{groups: groups} do
	+ group =
	+ groups
	+ \|> Emoji.match_extra("/emoji/custom/folder/another_folder/some_file.png")
	+ \|> to_string()
	+
	+ assert group == "wildcard files"
	+ end
	+
	+ test "config for special file", %{groups: groups} do
	+ group =
	+ groups
	+ \|> Emoji.match_extra("/emoji/custom/special.png")
	+ \|> to_string()
	+
	+ assert group == "special file"
	+ end
	+
	+ test "no mathing returns nil", %{groups: groups} do
	+ group =
	+ groups
	+ \|> Emoji.match_extra("/emoji/some_undefined.png")
	+
	+ refute group
	+ end
	+ end
	+end
	diff --git a/test/formatter_test.exs b/test/formatter_test.exs
	index fcdf931b7..e74985c4e 100644
	--- a/test/formatter_test.exs
	+++ b/test/formatter_test.exs
	@@ -1,293 +1,295 @@
	# 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: %Pleroma.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
	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)
	third_user = insert(:user)
	text = " @#{user.nickname} hey dude i hate @#{third_user.nickname}"
	{expected_text, mentions, [] = _tags} = Formatter.linkify(text, safe_mention: true)

	assert mentions == [{"@#{user.nickname}", 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='#{
	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
	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 :moominmamma:"

	expected_result =
	"I love <img height=\"32px\" width=\"32px\" alt=\"moominmamma\" title=\"moominmamma\" src=\"/finmoji/128px/moominmamma-128.png\" />"

	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 height=\"32px\" width=\"32px\" 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 :moominmamma:"

	- assert Formatter.get_emoji(text) == [{"moominmamma", "/finmoji/128px/moominmamma-128.png"}]
	+ assert Formatter.get_emoji(text) == [
	+ {"moominmamma", "/finmoji/128px/moominmamma-128.png", "Finmoji"}
	+ ]
	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/registration_test.exs b/test/registration_test.exs
	new file mode 100644
	index 000000000..6143b82c7
	--- /dev/null
	+++ b/test/registration_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.RegistrationTest do
	+ use Pleroma.DataCase
	+
	+ import Pleroma.Factory
	+
	+ alias Pleroma.Registration
	+ alias Pleroma.Repo
	+
	+ describe "generic changeset" do
	+ test "requires :provider, :uid" do
	+ registration = build(:registration, provider: nil, uid: nil)
	+
	+ cs = Registration.changeset(registration, %{})
	+ refute cs.valid?
	+
	+ assert [
	+ provider: {"can't be blank", [validation: :required]},
	+ uid: {"can't be blank", [validation: :required]}
	+ ] == cs.errors
	+ end
	+
	+ test "ensures uniqueness of [:provider, :uid]" do
	+ registration = insert(:registration)
	+ registration2 = build(:registration, provider: registration.provider, uid: registration.uid)
	+
	+ cs = Registration.changeset(registration2, %{})
	+ assert cs.valid?
	+
	+ assert {:error,
	+ %Ecto.Changeset{
	+ errors: [
	+ uid:
	+ {"has already been taken",
	+ [constraint: :unique, constraint_name: "registrations_provider_uid_index"]}
	+ ]
	+ }} = Repo.insert(cs)
	+
	+ # Note: multiple :uid values per [:user_id, :provider] are intentionally allowed
	+ cs2 = Registration.changeset(registration2, %{uid: "available.uid"})
	+ assert cs2.valid?
	+ assert {:ok, _} = Repo.insert(cs2)
	+
	+ cs3 = Registration.changeset(registration2, %{provider: "provider2"})
	+ assert cs3.valid?
	+ assert {:ok, _} = Repo.insert(cs3)
	+ end
	+
	+ test "allows `nil` :user_id (user-unbound registration)" do
	+ registration = build(:registration, user_id: nil)
	+ cs = Registration.changeset(registration, %{})
	+ assert cs.valid?
	+ assert {:ok, _} = Repo.insert(cs)
	+ end
	+ end
	+end
	diff --git a/test/support/factory.ex b/test/support/factory.ex
	index 608f8d46b..ea59912cf 100644
	--- a/test/support/factory.ex
	+++ b/test/support/factory.ex
	@@ -1,278 +1,294 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Factory do
	use ExMachina.Ecto, repo: Pleroma.Repo

	def user_factory do
	user = %Pleroma.User{
	name: sequence(:name, &"Test テスト User #{&1}"),
	email: sequence(:email, &"user#{&1}@example.com"),
	nickname: sequence(:nickname, &"nick#{&1}"),
	password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
	bio: sequence(:bio, &"Tester Number #{&1}"),
	info: %{}
	}

	%{
	user
	\| ap_id: Pleroma.User.ap_id(user),
	follower_address: Pleroma.User.ap_followers(user),
	following: [Pleroma.User.ap_id(user)]
	}
	end

	def note_factory(attrs \\ %{}) do
	text = sequence(:text, &"This is :moominmamma: note #{&1}")

	user = insert(:user)

	data = %{
	"type" => "Note",
	"content" => text,
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"likes" => [],
	"like_count" => 0,
	"context" => "2hu",
	"summary" => "2hu",
	"tag" => ["2hu"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def direct_note_factory do
	user2 = insert(:user)

	%Pleroma.Object{data: data} = note_factory()
	%Pleroma.Object{data: Map.merge(data, %{"to" => [user2.ap_id]})}
	end

	def article_factory do
	note_factory()
	\|> Map.put("type", "Article")
	end

	def tombstone_factory do
	data = %{
	"type" => "Tombstone",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"formerType" => "Note",
	"deleted" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Object{
	data: data
	}
	end

	def direct_note_activity_factory do
	dm = insert(:direct_note)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => dm.data["actor"],
	"to" => dm.data["to"],
	"object" => dm.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => dm.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def note_activity_factory(attrs \\ %{}) do
	note = attrs[:note] \|\| insert(:note)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"],
	"object" => note.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def article_activity_factory do
	article = insert(:article)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => article.data["actor"],
	"to" => article.data["to"],
	"object" => article.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => article.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def announce_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Announce",
	"actor" => note_activity.actor,
	"object" => note_activity.data["id"],
	"to" => [user.follower_address, note_activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => note_activity.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: user.ap_id,
	recipients: data["to"]
	}
	end

	def like_activity_factory do
	note_activity = insert(:note_activity)
	user = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Like",
	"object" => note_activity.data["object"]["id"],
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data
	}
	end

	def follow_activity_factory do
	follower = insert(:user)
	followed = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data,
	actor: follower.ap_id
	}
	end

	def websub_subscription_factory do
	%Pleroma.Web.Websub.WebsubServerSubscription{
	topic: "http://example.org",
	callback: "http://example.org/callback",
	secret: "here's a secret",
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 100),
	state: "requested"
	}
	end

	def websub_client_subscription_factory do
	%Pleroma.Web.Websub.WebsubClientSubscription{
	topic: "http://example.org",
	secret: "here's a secret",
	valid_until: nil,
	state: "requested",
	subscribers: []
	}
	end

	def oauth_app_factory do
	%Pleroma.Web.OAuth.App{
	client_name: "Some client",
	redirect_uris: "https://example.com/callback",
	scopes: ["read", "write", "follow", "push"],
	website: "https://example.com",
	client_id: Ecto.UUID.generate(),
	client_secret: "aaa;/&bbb"
	}
	end

	def instance_factory do
	%Pleroma.Instances.Instance{
	host: "domain.com",
	unreachable_since: nil
	}
	end

	def oauth_token_factory do
	oauth_app = insert(:oauth_app)

	%Pleroma.Web.OAuth.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	refresh_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	user: build(:user),
	app_id: oauth_app.id,
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10)
	}
	end

	def oauth_authorization_factory do
	%Pleroma.Web.OAuth.Authorization{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	scopes: ["read", "write", "follow", "push"],
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user),
	app: build(:oauth_app)
	}
	end

	def push_subscription_factory do
	%Pleroma.Web.Push.Subscription{
	user: build(:user),
	token: build(:oauth_token),
	endpoint: "https://example.com/example/1234",
	key_auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	key_p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA=",
	data: %{}
	}
	end

	def notification_factory do
	%Pleroma.Notification{
	user: build(:user)
	}
	end

	def scheduled_activity_factory do
	%Pleroma.ScheduledActivity{
	user: build(:user),
	scheduled_at: NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(60), :millisecond),
	params: build(:note) \|> Map.from_struct() \|> Map.get(:data)
	}
	end
	+
	+ def registration_factory do
	+ user = insert(:user)
	+
	+ %Pleroma.Registration{
	+ user: user,
	+ provider: "twitter",
	+ uid: "171799000",
	+ info: %{
	+ "name" => "John Doe",
	+ "email" => "john@doe.com",
	+ "nickname" => "johndoe",
	+ "description" => "My bio"
	+ }
	+ }
	+ end
	end
	diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
	index 62b973c4f..47cffe257 100644
	--- a/test/web/activity_pub/transmogrifier_test.exs
	+++ b/test/web/activity_pub/transmogrifier_test.exs
	@@ -1,1257 +1,1254 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.Websub.WebsubClientSubscription

	import Pleroma.Factory
	alias Pleroma.Web.CommonAPI

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "handle_incoming" do
	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity == returned_activity
	end

	test "it fetches replied-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

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

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity =
	Activity.get_create_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	assert returned_activity.data["object"]["inReplyToAtomUri"] ==
	"https://shitposter.club/notice/2827873"

	assert returned_activity.data["object"]["inReplyToStatusId"] == activity.id
	end

	test "it works for incoming notices" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"

	assert data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert data["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert data["actor"] == "http://mastodon.example.org/users/admin"

	object = data["object"]
	assert object["id"] == "http://mastodon.example.org/users/admin/statuses/99512778738411822"

	assert object["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert object["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert object["actor"] == "http://mastodon.example.org/users/admin"
	assert object["attributedTo"] == "http://mastodon.example.org/users/admin"

	assert object["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert object["sensitive"] == true

	user = User.get_by_ap_id(object["actor"])

	assert user.info.note_count == 1
	end

	test "it works for incoming notices with hashtags" do
	data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert Enum.at(data["object"]["tag"], 2) == "moo"
	end

	test "it works for incoming notices with contentMap" do
	data =
	File.read!("test/fixtures/mastodon-post-activity-contentmap.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["object"]["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it works for incoming notices with to/cc not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["object"]["content"] ==
	"<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
	end

	test "it works for incoming announces with actor being inlined (kroeg)" do
	data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://puckipedia.com/"
	end

	test "it works for incoming notices with tag not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-array-less-emoji.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["object"]["emoji"] == %{
	"icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
	}

	data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert "test" in data["object"]["tag"]
	end

	test "it works for incoming notices with url not being a string (prismo)" do
	data = File.read!("test/fixtures/prismo-url-map.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["object"]["url"] == "https://prismo.news/posts/83"
	end

	test "it cleans up incoming notices which are not really DMs" do
	user = insert(:user)
	other_user = insert(:user)

	to = [user.ap_id, other_user.ap_id]

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["to"] == []
	assert data["cc"] == to

	object = data["object"]

	assert object["to"] == []
	assert object["cc"] == to
	end

	test "it works for incoming follow requests" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Follow"
	assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"
	assert User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follow requests from hubzilla" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/hubzilla-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Utils.normalize_params()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
	assert data["type"] == "Follow"
	assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
	assert User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming likes" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Like"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
	assert data["object"] == activity.data["object"]["id"]
	end

	test "it returns an error for incoming unlikes wihout a like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	assert Transmogrifier.handle_incoming(data) == :error
	end

	test "it works for incoming unlikes with an existing like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	{:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", like_data)
	\|> Map.put("actor", like_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming announces" do
	data = File.read!("test/fixtures/mastodon-announce.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] ==
	"http://mastodon.example.org/users/admin/statuses/99541947525187367"

	assert Activity.get_create_by_object_ap_id(data["object"])
	end

	test "it works for incoming announces with an existing activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] == activity.data["object"]["id"]

	assert Activity.get_create_by_object_ap_id(data["object"]).id == activity.id
	end

	test "it does not clobber the addressing on announce activities" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])
	\|> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
	\|> Map.put("cc", [])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
	end

	test "it ensures that as:Public activities make it to their followers collection" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["cc"] == [User.ap_followers(user)]
	end

	test "it ensures that address fields become lists" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert !is_nil(data["to"])
	assert !is_nil(data["cc"])
	end

	test "it works for incoming update activities" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.name == "gargle"

	assert user.avatar["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]

	assert user.info.banner["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]

	assert user.bio == "<p>Some bio</p>"
	end

	test "it works for incoming update activities which lock the account" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])
	\|> Map.put("manuallyApprovesFollowers", true)

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.info.locked == true
	end

	test "it works for incoming deletes" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"]["id"])

	data =
	data
	\|> Map.put("object", object)
	\|> Map.put("actor", activity.data["actor"])

	{:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)

	refute Activity.get_by_id(activity.id)
	end

	test "it fails for incoming deletes with spoofed origin" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("id", activity.data["object"]["id"])

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

	:error = Transmogrifier.handle_incoming(data)

	assert Activity.get_by_id(activity.id)
	end

	test "it works for incoming unannounces with an existing notice" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	announce_data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"]["id"])

	{:ok, %Activity{data: announce_data, local: false}} =
	Transmogrifier.handle_incoming(announce_data)

	data =
	File.read!("test/fixtures/mastodon-undo-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", announce_data)
	\|> Map.put("actor", announce_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Announce"
	assert data["object"]["object"] == activity.data["object"]["id"]

	assert data["object"]["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
	end

	test "it works for incomming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", follow_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming blocks" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_by_ap_id(data["actor"])

	assert User.blocks?(blocker, user)
	end

	test "incoming blocks successfully tear down any follow relationship" do
	blocker = insert(:user)
	blocked = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", blocked.ap_id)
	\|> Map.put("actor", blocker.ap_id)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == blocked.ap_id
	assert data["actor"] == blocker.ap_id

	blocker = User.get_by_ap_id(data["actor"])
	blocked = User.get_by_ap_id(data["object"])

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "it works for incoming unblocks with an existing block" do
	user = insert(:user)

	block_data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)

	data =
	File.read!("test/fixtures/mastodon-unblock-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", block_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Block"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_by_ap_id(data["actor"])

	refute User.blocks?(blocker, user)
	end

	test "it works for incoming accepts which were pre-accepted" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follower} = User.follow(follower, followed)
	assert User.following?(follower, followed) == true

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	object =
	accept_data["object"]
	\|> Map.put("actor", follower.ap_id)
	\|> Map.put("id", follow_activity.data["id"])

	accept_data = Map.put(accept_data, "object", object)

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	refute activity.local

	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which were orphaned" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it fails for incoming accepts which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it fails for incoming rejects which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	accept_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it works for incoming rejects which are orphaned" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follower} = User.follow(follower, followed)
	{:ok, _follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	reject_data =
	Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(reject_data)
	refute activity.local

	follower = User.get_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it works for incoming rejects which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follower} = User.follow(follower, followed)
	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)

	follower = User.get_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it rejects activities without a valid ID" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Map.put("id", "")

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it remaps video URLs as attachments if necessary" do
	{:ok, object} =
	ActivityPub.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	attachment = %{
	"type" => "Link",
	"mediaType" => "video/mp4",
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mimeType" => "video/mp4",
	"size" => 5_015_880,
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	],
	"width" => 480
	}

	assert object.data["url"] ==
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"

	assert object.data["attachment"] == [attachment]
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
	object = Object.normalize(activity.data["object"])

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, object.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	assert activity.data["object"] == [user.ap_id, object.data["id"]]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end
	end

	describe "prepare outgoing" do
	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end

	test "it adds the sensitive property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["sensitive"]
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["@context"] ==
	Pleroma.Web.ActivityPub.Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it translates ostatus IDs to external URLs" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [referent_activity]} = OStatus.handle_incoming(incoming)

	user = insert(:user)

	{:ok, activity, _} = CommonAPI.favorite(referent_activity.id, user)
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"] == "http://gs.example.org:4040/index.php/notice/29"
	end

	test "it translates ostatus reply_to IDs to external URLs" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [referred_activity]} = OStatus.handle_incoming(incoming)

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "HI!", "in_reply_to_status_id" => referred_activity.id})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["inReplyTo"] == "http://gs.example.org:4040/index.php/notice/29"
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu"})

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	end

	test "it adds like collection to object" do
	activity = insert(:note_activity)
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["likes"]["type"] == "OrderedCollection"
	assert modified["object"]["likes"]["totalItems"] == 0
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "@#{other_user.nickname} :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "@#{other_user.nickname} :moominmamma:",
	"visibility" => "direct"
	})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == true
	end
	end

	describe "user upgrade" do
	test "it upgrades a user to activitypub" do
	user =
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	user_two = insert(:user, %{following: [user.follower_address]})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
	{:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
	assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients

	user = User.get_by_id(user.id)
	assert user.info.note_count == 1

	{:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
	assert user.info.ap_enabled
	assert user.info.note_count == 1
	assert user.follower_address == "https://niu.moe/users/rye/followers"

	- # Wait for the background task
	- :timer.sleep(1000)
	-
	user = User.get_by_id(user.id)
	assert user.info.note_count == 1

	activity = Activity.get_by_id(activity.id)
	assert user.follower_address in activity.recipients

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]
	} = user.avatar

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]
	} = user.info.banner

	refute "..." in activity.recipients

	unrelated_activity = Activity.get_by_id(unrelated_activity.id)
	refute user.follower_address in unrelated_activity.recipients

	user_two = User.get_by_id(user_two.id)
	assert user.follower_address in user_two.following
	refute "..." in user_two.following
	end
	end

	describe "maybe_retire_websub" do
	test "it deletes all websub client subscripitions with the user as topic" do
	subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/rye.atom"}
	{:ok, ws} = Repo.insert(subscription)

	subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/pasty.atom"}
	{:ok, ws2} = Repo.insert(subscription)

	Transmogrifier.maybe_retire_websub("https://niu.moe/users/rye")

	refute Repo.get(WebsubClientSubscription, ws.id)
	assert Repo.get(WebsubClientSubscription, ws2.id)
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	test "it rejects objects with a bogus origin" do
	{:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity.json")
	end

	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it rejects objects when attributedTo is wrong (variant 1)" do
	{:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity2.json")
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it rejects objects when attributedTo is wrong (variant 2)" do
	{:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity3.json")
	end

	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end
	end

	describe "general origin containment" do
	test "contain_origin_from_id() catches obvious spoofing attempts" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:error =
	Transmogrifier.contain_origin_from_id(
	"http://example.org/~alyssa/activities/1234.json",
	data
	)
	end

	test "contain_origin_from_id() allows alternate IDs within the same origin domain" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:ok =
	Transmogrifier.contain_origin_from_id(
	"http://example.com/~alyssa/activities/1234",
	data
	)
	end

	test "contain_origin_from_id() allows matching IDs" do
	data = %{
	"id" => "http://example.com/~alyssa/activities/1234.json"
	}

	:ok =
	Transmogrifier.contain_origin_from_id(
	"http://example.com/~alyssa/activities/1234.json",
	data
	)
	end

	test "users cannot be collided through fake direction spoofing attempts" do
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	{:error, _} = User.get_or_fetch_by_ap_id("https://n1u.moe/users/rye")
	end

	test "all objects with fake directions are rejected by the object fetcher" do
	{:error, _} =
	ActivityPub.fetch_and_contain_remote_object_from_id(
	"https://info.pleroma.site/activity4.json"
	)
	end
	end

	describe "reserialization" do
	test "successfully reserializes a message with inReplyTo == nil" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

	{:ok, activity} = Transmogrifier.handle_incoming(message)

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end

	test "successfully reserializes a message with AS2 objects in IR" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id,
	"tag" => [
	%{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
	%{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
	]
	},
	"actor" => user.ap_id
	}

	{:ok, activity} = Transmogrifier.handle_incoming(message)

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end
	end
	end
	diff --git a/test/web/activity_pub/utils_test.exs b/test/web/activity_pub/utils_test.exs
	index 6b9961d82..758214e68 100644
	--- a/test/web/activity_pub/utils_test.exs
	+++ b/test/web/activity_pub/utils_test.exs
	@@ -1,196 +1,208 @@
	defmodule Pleroma.Web.ActivityPub.UtilsTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	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 "fetch the latest Block" do
	test "fetches the latest Block activity" do
	blocker = insert(:user)
	blocked = insert(:user)
	{:ok, activity} = ActivityPub.block(blocker, blocked)

	assert activity == Utils.fetch_latest_block(blocker, blocked)
	end
	end

	describe "determine_explicit_mentions()" do
	test "works with an object that has mentions" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that does not have mentions" do
	object = %{
	"tag" => [
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has mentions and other tags" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	},
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that has no tags" do
	object = %{}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has only IR tags" do
	object = %{"tag" => ["2hu"]}

	assert Utils.determine_explicit_mentions(object) == []
	end
	end

	describe "make_like_data" do
	setup do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	[user: user, other_user: other_user, third_user: third_user]
	end

	test "addresses actor's follower address if the activity is public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id, other_user.follower_address])
	expected_cc = Enum.sort(["https://www.w3.org/ns/activitystreams#Public", third_user.ap_id])

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end

	test "does not adress actor's follower address if the activity is not public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id])
	expected_cc = [third_user.ap_id]

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
	"visibility" => "private"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end
	end

	describe "fetch_ordered_collection" do
	import Tesla.Mock

	test "fetches the first OrderedCollectionPage when an OrderedCollection is encountered" do
	mock(fn
	%{method: :get, url: "http://mastodon.com/outbox"} ->
	json(%{"type" => "OrderedCollection", "first" => "http://mastodon.com/outbox?page=true"})

	%{method: :get, url: "http://mastodon.com/outbox?page=true"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => ["ok"]})
	end)

	assert Utils.fetch_ordered_collection("http://mastodon.com/outbox", 1) == ["ok"]
	end

	test "fetches several pages in the right order one after another, but only the specified amount" do
	mock(fn
	%{method: :get, url: "http://example.com/outbox"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [0],
	"next" => "http://example.com/outbox?page=1"
	})

	%{method: :get, url: "http://example.com/outbox?page=1"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [1],
	"next" => "http://example.com/outbox?page=2"
	})

	%{method: :get, url: "http://example.com/outbox?page=2"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => [2]})
	end)

	assert Utils.fetch_ordered_collection("http://example.com/outbox", 0) == [0]
	assert Utils.fetch_ordered_collection("http://example.com/outbox", 1) == [0, 1]
	end

	test "returns an error if the url doesn't have an OrderedCollection/Page" do
	mock(fn
	%{method: :get, url: "http://example.com/not-an-outbox"} ->
	json(%{"type" => "NotAnOutbox"})
	end)

	assert {:error, _} = Utils.fetch_ordered_collection("http://example.com/not-an-outbox", 1)
	end

	test "returns the what was collected if there are less pages than specified" do
	mock(fn
	%{method: :get, url: "http://example.com/outbox"} ->
	json(%{
	"type" => "OrderedCollectionPage",
	"orderedItems" => [0],
	"next" => "http://example.com/outbox?page=1"
	})

	%{method: :get, url: "http://example.com/outbox?page=1"} ->
	json(%{"type" => "OrderedCollectionPage", "orderedItems" => [1]})
	end)

	assert Utils.fetch_ordered_collection("http://example.com/outbox", 5) == [0, 1]
	end
	end
	+
	+ test "make_json_ld_header/0" do
	+ assert Utils.make_json_ld_header() == %{
	+ "@context" => [
	+ "https://www.w3.org/ns/activitystreams",
	+ "http://localhost:4001/schemas/litepub-0.1.jsonld",
	+ %{
	+ "@language" => "und"
	+ }
	+ ]
	+ }
	+ 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 30694b7ed..ba47f2ab9 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,658 +1,656 @@
	# 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.User
	import Pleroma.Factory

	describe "/api/pleroma/admin/user" 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/user?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/user", %{
	"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/user/follow" do
	test "allows to force-follow another user" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)
	follower = insert(:user)

	- _conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> put_req_header("accept", "application/json")
	- \|> post("/api/pleroma/admin/user/follow", %{
	- "follower" => follower.nickname,
	- "followed" => user.nickname
	- })
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> put_req_header("accept", "application/json")
	+ \|> post("/api/pleroma/admin/user/follow", %{
	+ "follower" => follower.nickname,
	+ "followed" => user.nickname
	+ })

	user = User.get_by_id(user.id)
	follower = User.get_by_id(follower.id)

	assert User.following?(follower, user)
	end
	end

	describe "/api/pleroma/admin/user/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)

	- _conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> put_req_header("accept", "application/json")
	- \|> post("/api/pleroma/admin/user/unfollow", %{
	- "follower" => follower.nickname,
	- "followed" => user.nickname
	- })
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> put_req_header("accept", "application/json")
	+ \|> post("/api/pleroma/admin/user/unfollow", %{
	+ "follower" => follower.nickname,
	+ "followed" => user.nickname
	+ })

	user = User.get_by_id(user.id)
	follower = User.get_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_by_id(user1.id).tags == ["x", "foo", "bar"]
	assert User.get_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_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_by_id(user1.id).tags == []
	assert User.get_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_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "/api/pleroma/admin/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/permission_group/#{admin.nickname}")

	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/permission_group/#{user.nickname}/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/permission_group/#{user.nickname}/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => false
	}
	end
	end

	describe "PUT /api/pleroma/admin/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/activation_status/#{user.nickname}", %{status: false})

	user = User.get_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/activation_status/#{user.nickname}", %{status: true})

	user = User.get_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/activation_status/#{user.nickname}", %{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/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

	Swoosh.TestAssertions.assert_email_sent(
	Pleroma.UserEmail.user_invitation_email(
	user,
	token_record,
	recipient_email,
	recipient_name
	)
	)
	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/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/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/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/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end
	end

	test "/api/pleroma/admin/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")

	assert conn.status == 200
	end

	test "/api/pleroma/admin/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/password_reset?nickname=#{user.nickname}")

	assert conn.status == 200
	end

	describe "GET /api/pleroma/admin/users" do
	test "renders users array for the first page" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, local: false, tags: ["foo", "bar"])

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?page=1")

	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"]
	}
	]
	}
	end

	test "renders empty array for the second page" do
	admin = insert(:user, info: %{is_admin: true})
	insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?page=2")

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => []
	}
	end

	test "regular search" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, nickname: "bob")

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/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 "regular search with page size" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?query=a&page_size=1&page=1")

	assert json_response(conn, 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" => []
	}
	]
	}

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?query=a&page_size=1&page=2")

	assert json_response(conn, 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" 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")

	assert json_response(conn, 200) == %{
	"count" => 2,
	"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" => []
	}
	]
	}
	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

	test "PUT /api/pleroma/admin/user/disable_2fa" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, otp_enabled: true, otp_secret: "xxx")

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put("/api/pleroma/admin/user/disable_2fa", %{nickname: user.nickname})

	assert json_response(conn, 200) == user.nickname
	refute refresh_record(user).otp_enabled
	end
	end
	diff --git a/test/web/auth/pleroma_authenticator_test.exs b/test/web/auth/pleroma_authenticator_test.exs
	index 5e1f2bcc2..ad57180b6 100644
	--- a/test/web/auth/pleroma_authenticator_test.exs
	+++ b/test/web/auth/pleroma_authenticator_test.exs
	@@ -1,61 +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.Auth.PleromaAuthenticatorTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Web.Auth.PleromaAuthenticator
	import Pleroma.Factory

	setup_all do
	:ok
	end

	test "get_user/authorization" do
	password = "testpassword"
	name = "AgentSmith"
	user = insert(:user, nickname: name, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
	-
	- res =
	- PleromaAuthenticator.get_user(%Plug.Conn{
	- params: %{"authorization" => %{"name" => name, "password" => password}}
	- })
	+ params = %{"authorization" => %{"name" => name, "password" => password}}
	+ res = PleromaAuthenticator.get_user(%Plug.Conn{params: params}, params)

	assert {:ok, user} == res
	end

	test "get_user/authorization with invalid password" do
	password = "testpassword"
	name = "AgentSmith"
	user = insert(:user, nickname: name, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
	-
	- res =
	- PleromaAuthenticator.get_user(%Plug.Conn{
	- params: %{"authorization" => %{"name" => name, "password" => "password"}}
	- })
	+ params = %{"authorization" => %{"name" => name, "password" => "password"}}
	+ res = PleromaAuthenticator.get_user(%Plug.Conn{params: params}, params)

	assert {:error, user} == res
	end

	test "get_user/grant_type_password" do
	password = "testpassword"
	name = "AgentSmith"
	user = insert(:user, nickname: name, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
	-
	- res =
	- PleromaAuthenticator.get_user(%Plug.Conn{
	- params: %{"grant_type" => "password", "username" => name, "password" => password}
	- })
	+ params = %{"grant_type" => "password", "username" => name, "password" => password}
	+ res = PleromaAuthenticator.get_user(%Plug.Conn{params: params}, params)

	assert {:ok, user} == res
	end

	test "error credintails" do
	password = "testpassword"
	name = "AgentSmith"
	_user = insert(:user, nickname: name, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
	- res = PleromaAuthenticator.get_user(%Plug.Conn{params: %{}})
	+ res = PleromaAuthenticator.get_user(%Plug.Conn{params: %{}}, %{})
	assert {:error, :invalid_credentials} == res
	end
	end
	diff --git a/test/web/mastodon_api/mastodon_api_controller_test.exs b/test/web/mastodon_api/mastodon_api_controller_test.exs
	index cd01116e2..e16862a48 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,2621 +1,2637 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Ecto.Changeset
	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.FilterView
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.Push
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "the home timeline", %{conn: conn} do
	user = insert(:user)
	following = insert(:user)

	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert Enum.empty?(json_response(conn, 200))

	{:ok, user} = User.follow(user, following)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end

	test "the public timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	conn =
	conn
	\|> get("/api/v1/timelines/public", %{"local" => "False"})

	assert length(json_response(conn, 200)) == 2

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "True"})

	assert [%{"content" => "test"}] = json_response(conn, 200)

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "1"})

	assert [%{"content" => "test"}] = json_response(conn, 200)
	end)
	end

	test "posting a status", %{conn: conn} do
	user = insert(:user)

	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	{:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
	# Six hours
	assert ttl > :timer.seconds(6 * 60 * 60 - 1)

	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response(conn_one, 200)

	assert Activity.get_by_id(id)

	conn_two =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => second_id} = json_response(conn_two, 200)

	assert id == second_id

	conn_three =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => third_id} = json_response(conn_three, 200)

	refute id == third_id
	end

	test "posting a sensitive status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a fake status", %{conn: conn} do
	user = insert(:user)

	real_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
	})

	real_status = json_response(real_conn, 200)

	assert real_status
	assert Object.get_by_ap_id(real_status["uri"])

	real_status =
	real_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	fake_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
	"preview" => true
	})

	fake_status = json_response(fake_conn, 200)

	assert fake_status
	refute Object.get_by_ap_id(fake_status["uri"])

	fake_status =
	fake_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	assert real_status == fake_status
	end

	test "posting a status with OGP link preview", %{conn: conn} do
	Pleroma.Config.put([:rich_media, :enabled], true)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "http://example.com/ogp"
	})

	assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	Pleroma.Config.put([:rich_media, :enabled], false)
	end

	test "posting a direct status", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	content = "direct cofe @#{user2.nickname}"

	conn =
	conn
	\|> assign(:user, user1)
	\|> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
	assert activity = Activity.get_by_id(id)
	assert activity.recipients == [user2.ap_id, user1.ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end

	test "direct timeline", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	# Only direct should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status
	assert status["url"] != direct.data["id"]

	# User should be able to see his own direct message
	res_conn =
	build_conn()
	\|> assign(:user, user_one)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status

	# Both should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/home")

	[_s1, _s2] = json_response(res_conn, 200)

	# Test pagination
	Enum.each(1..20, fn _ ->
	{:ok, _} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})
	end)

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	statuses = json_response(res_conn, 200)
	assert length(statuses) == 20

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})

	[status] = json_response(res_conn, 200)

	assert status["url"] != direct.data["id"]
	end

	test "doesn't include DMs from blocked users", %{conn: conn} do
	blocker = insert(:user)
	blocked = insert(:user)
	user = insert(:user)
	{:ok, blocker} = User.block(blocker, blocked)

	{:ok, _blocked_direct} =
	CommonAPI.post(blocked, %{
	"status" => "Hi @#{blocker.nickname}!",
	"visibility" => "direct"
	})

	{:ok, direct} =
	CommonAPI.post(user, %{
	"status" => "Hi @#{blocker.nickname}!",
	"visibility" => "direct"
	})

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)
	assert status["id"] == direct.id
	end

	test "replying to a status", %{conn: conn} do
	user = insert(:user)

	{:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Activity.get_by_id(id)

	assert activity.data["context"] == replied_to.data["context"]
	assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
	end

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Activity.get_by_id(id)

	assert activity
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "apps/verify_credentials", %{conn: conn} do
	token = insert(:oauth_token)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> get("/api/v1/apps/verify_credentials")

	app = Repo.preload(token, :app).app

	expected = %{
	"name" => app.client_name,
	"website" => app.website,
	"vapid_key" => Push.vapid_config() \|> Keyword.get(:public_key)
	}

	assert expected == json_response(conn, 200)
	end

	test "creates an oauth app", %{conn: conn} do
	user = insert(:user)
	app_attrs = build(:oauth_app)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/apps", %{
	client_name: app_attrs.client_name,
	redirect_uris: app_attrs.redirect_uris
	})

	[app] = Repo.all(App)

	expected = %{
	"name" => app.client_name,
	"website" => app.website,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret,
	"id" => app.id \|> to_string(),
	"redirect_uri" => app.redirect_uris,
	"vapid_key" => Push.vapid_config() \|> Keyword.get(:public_key)
	}

	assert expected == json_response(conn, 200)
	end

	test "get a status", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(activity.id)
	end

	describe "deleting a status" do
	test "when you created it", %{conn: conn} do
	activity = insert(:note_activity)
	author = User.get_by_ap_id(activity.data["actor"])

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

	refute Activity.get_by_id(activity.id)
	end

	test "when you didn't create it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{"error" => _} = json_response(conn, 403)

	assert Activity.get_by_id(activity.id) == activity
	end

	test "when you're an admin or moderator", %{conn: conn} do
	activity1 = insert(:note_activity)
	activity2 = insert(:note_activity)
	admin = insert(:user, info: %{is_admin: true})
	moderator = insert(:user, info: %{is_moderator: true})

	res_conn =
	conn
	\|> assign(:user, admin)
	\|> delete("/api/v1/statuses/#{activity1.id}")

	assert %{} = json_response(res_conn, 200)

	res_conn =
	conn
	\|> assign(:user, moderator)
	\|> delete("/api/v1/statuses/#{activity2.id}")

	assert %{} = json_response(res_conn, 200)

	refute Activity.get_by_id(activity1.id)
	refute Activity.get_by_id(activity2.id)
	end
	end

	describe "filters" do
	test "creating a filter", %{conn: conn} do
	user = insert(:user)

	filter = %Pleroma.Filter{
	phrase: "knights",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

	assert response = json_response(conn, 200)
	assert response["phrase"] == filter.phrase
	assert response["context"] == filter.context
	assert response["id"] != nil
	assert response["id"] != ""
	end

	test "fetching a list of filters", %{conn: conn} do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	query_two = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "who",
	context: ["home"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.create(query_two)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters")
	\|> json_response(200)

	assert response ==
	render_json(
	FilterView,
	"filters.json",
	filters: [filter_two, filter_one]
	)
	end

	test "get a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters/#{filter.filter_id}")

	assert _response = json_response(conn, 200)
	end

	test "update a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, _filter} = Pleroma.Filter.create(query)

	new = %Pleroma.Filter{
	phrase: "nii",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/filters/#{query.filter_id}", %{
	phrase: new.phrase,
	context: new.context
	})

	assert response = json_response(conn, 200)
	assert response["phrase"] == new.phrase
	assert response["context"] == new.context
	end

	test "delete a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/filters/#{filter.filter_id}")

	assert response = json_response(conn, 200)
	assert response == %{}
	end
	end

	describe "lists" do
	test "creating a list", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists", %{"title" => "cuties"})

	assert %{"title" => title} = json_response(conn, 200)
	assert title == "cuties"
	end

	test "adding users to a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [other_user.follower_address]
	end

	test "removing users from a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)
	{:ok, list} = Pleroma.List.follow(list, third_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [third_user.follower_address]
	end

	test "listing users in a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "retrieving a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(list.id)
	end

	test "renaming a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})

	assert %{"title" => name} = json_response(conn, 200)
	assert name == "newname"
	end

	test "deleting a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}")

	assert %{} = json_response(conn, 200)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end

	test "list timeline", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
	{:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_two.id)
	end

	test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})

	{:ok, _activity_two} =
	TwitterAPI.create_status(other_user, %{
	"status" => "Marisa is cute.",
	"visibility" => "private"
	})

	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

	assert [%{"id" => id}] = json_response(conn, 200)

	assert id == to_string(activity_one.id)
	end
	end

	describe "notifications" do
	test "list of notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] = json_response(conn, 200)
	assert response == expected_response
	end

	test "getting a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/dismiss", %{"id" => notification.id})

	assert %{} = json_response(conn, 200)
	end

	test "clearing all notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/clear")

	assert %{} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	assert all = json_response(conn, 200)
	assert all == []
	end

	test "paginates notifications using min_id, since_id, max_id, and limit", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	notification1_id = Repo.get_by(Notification, activity_id: activity1.id).id \|> to_string()
	notification2_id = Repo.get_by(Notification, activity_id: activity2.id).id \|> to_string()
	notification3_id = Repo.get_by(Notification, activity_id: activity3.id).id \|> to_string()
	notification4_id = Repo.get_by(Notification, activity_id: activity4.id).id \|> to_string()

	conn =
	conn
	\|> assign(:user, user)

	# min_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result

	# since_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	# max_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
	end

	test "filters notifications using exclude_types", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, other_user)
	{:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)

	mention_notification_id =
	Repo.get_by(Notification, activity_id: mention_activity.id).id \|> to_string()

	favorite_notification_id =
	Repo.get_by(Notification, activity_id: favorite_activity.id).id \|> to_string()

	reblog_notification_id =
	Repo.get_by(Notification, activity_id: reblog_activity.id).id \|> to_string()

	follow_notification_id =
	Repo.get_by(Notification, activity_id: follow_activity.id).id \|> to_string()

	conn =
	conn
	\|> assign(:user, user)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["mention", "favourite", "reblog"]})

	assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["favourite", "reblog", "follow"]})

	assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["reblog", "follow", "mention"]})

	assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["follow", "mention", "favourite"]})

	assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)
	end
	end

	describe "reblogging" do
	test "reblogs and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "unreblogging" do
	test "unreblogs and returns the unreblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	{:ok, _, _} = CommonAPI.repeat(activity.id, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unreblog")

	assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "favoriting" do
	test "favs a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 500 for a wrong id", %{conn: conn} do
	user = insert(:user)

	resp =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/1/favourite")
	\|> json_response(500)

	assert resp == "Something went wrong"
	end
	end

	describe "unfavoriting" do
	test "unfavorites a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	{:ok, _, _} = CommonAPI.favorite(activity.id, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")

	assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "user timelines" do
	test "gets a users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, user_three} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	"status" => "Hi, @#{user_two.nickname}.",
	"visibility" => "direct"
	})

	{:ok, private_activity} =
	CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id}] = json_response(resp, 200)
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "unimplemented pinned statuses feature", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_by_ap_id(note.data["actor"])

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")

	assert json_response(conn, 200) == []
	end

	test "gets an users media", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_by_ap_id(note.data["actor"])

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	media =
	TwitterAPI.upload(file, user, "json")
	\|> Poison.decode!()

	{:ok, image_post} =
	TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)
	end

	test "gets a user's statuses without reblogs", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, _, _} = CommonAPI.repeat(post.id, user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)
	end
	end

	describe "user relationships" do
	test "returns the relationships for the current user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})

	assert [relationship] = json_response(conn, 200)

	assert to_string(other_user.id) == relationship["id"]
	end
	end

	describe "locked accounts" do
	test "/api/v1/follow_requests works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = User.get_by_id(user.id)
	other_user = User.get_by_id(other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/follow_requests")

	assert [relationship] = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]
	end

	test "/api/v1/follow_requests/:id/authorize works" do
	user = insert(:user, %{info: %User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = User.get_by_id(user.id)
	other_user = User.get_by_id(other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/authorize")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = User.get_by_id(user.id)
	other_user = User.get_by_id(other_user.id)

	assert User.following?(other_user, user) == true
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "/api/v1/follow_requests/:id/reject works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = User.get_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/reject")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = User.get_by_id(user.id)
	other_user = User.get_by_id(other_user.id)

	assert User.following?(other_user, user) == false
	end
	end

	test "account fetching", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(user.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/-1")

	assert %{"error" => "Can't find user"} = json_response(conn, 404)
	end

	test "account fetching also works nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == user.id
	end

	test "media upload", %{conn: conn} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	desc = "Description of the image"

	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/media", %{"file" => file, "description" => desc})

	assert media = json_response(conn, 200)

	assert media["type"] == "image"
	assert media["description"] == desc
	assert media["id"]

	object = Repo.get(Object, media["id"])
	assert object.data["actor"] == User.ap_id(user)
	end

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2hu")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)

	# works for different capitalization too
	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2HU")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)
	end)
	end

	test "multi-hashtag timeline", %{conn: conn} do
	user = insert(:user)

	{:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
	{:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
	{:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})

	any_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})

	[status_none, status_test1, status_test] = json_response(any_test, 200)

	assert to_string(activity_test.id) == status_test["id"]
	assert to_string(activity_test1.id) == status_test1["id"]
	assert to_string(activity_none.id) == status_none["id"]

	restricted_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})

	assert [status_test1] == json_response(restricted_test, 200)

	all_test = conn \|> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})

	assert [status_none] == json_response(all_test, 200)
	end

	test "getting followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "getting followers, hide_followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_followers: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [] == json_response(conn, 200)
	end

	test "getting followers, hide_followers, same user requesting", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_followers: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response(conn, 200)
	end

	test "getting followers, pagination", %{conn: conn} do
	user = insert(:user)
	follower1 = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)
	{:ok, _} = User.follow(follower1, user)
	{:ok, _} = User.follow(follower2, user)
	{:ok, _} = User.follow(follower3, user)

	conn =
	conn
	\|> assign(:user, user)

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
	assert id3 == follower3.id
	assert id2 == follower2.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
	assert id2 == follower2.id
	assert id1 == follower1.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3.id}")

	assert [%{"id" => id2}] = json_response(res_conn, 200)
	assert id2 == follower2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/since_id=#{follower2.id}/
	assert link_header =~ ~r/max_id=#{follower2.id}/
	end

	test "getting following", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "getting following, hide_follows", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [] == json_response(conn, 200)
	end

	test "getting following, hide_follows, same user requesting", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response(conn, 200)
	end

	test "getting following, pagination", %{conn: conn} do
	user = insert(:user)
	following1 = insert(:user)
	following2 = insert(:user)
	following3 = insert(:user)
	{:ok, _} = User.follow(user, following1)
	{:ok, _} = User.follow(user, following2)
	{:ok, _} = User.follow(user, following3)

	conn =
	conn
	\|> assign(:user, user)

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
	assert id3 == following3.id
	assert id2 == following2.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")

	assert [%{"id" => id2}] = json_response(res_conn, 200)
	assert id2 == following2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/since_id=#{following2.id}/
	assert link_header =~ ~r/max_id=#{following2.id}/
	end

	test "following / unfollowing a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/follow")

	assert %{"id" => _id, "following" => true} = json_response(conn, 200)

	user = User.get_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unfollow")

	assert %{"id" => _id, "following" => false} = json_response(conn, 200)

	user = User.get_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follows", %{"uri" => other_user.nickname})

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "muting / unmuting a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/mute")

	assert %{"id" => _id, "muting" => true} = json_response(conn, 200)

	user = User.get_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false} = json_response(conn, 200)
	end

	test "getting a list of mutes", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.mute(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)

	user = User.get_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
	end

	test "getting a list of blocks", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.block(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a domain", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "getting a list of domain blocks", %{conn: conn} do
	user = insert(:user)

	{:ok, user} = User.block_domain(user, "bad.site")
	{:ok, user} = User.block_domain(user, "even.worse.site")

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/domain_blocks")

	domain_blocks = json_response(conn, 200)

	assert "bad.site" in domain_blocks
	assert "even.worse.site" in domain_blocks
	end

	test "unimplemented follow_requests, blocks, domain blocks" do
	user = insert(:user)

	["blocks", "domain_blocks", "follow_requests"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/#{endpoint}")

	assert [] = json_response(conn, 200)
	end)
	end

	test "account search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "shp"})
	\|> json_response(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_two.nickname in result_ids
	assert user_three.nickname in result_ids

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "2hu"})
	\|> json_response(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_three.nickname in result_ids
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	"status" => "This is about 2hu, but private",
	"visibility" => "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "2hu"})

	assert results = json_response(conn, 200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == []

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search fetches remote statuses", %{conn: conn} do
	capture_log(fn ->
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})

	assert results = json_response(conn, 200)

	[status] = results["statuses"]
	assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

	test "search doesn't show statuses that it shouldn't", %{conn: conn} do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	"status" => "This is about 2hu, but private",
	"visibility" => "private"
	})

	capture_log(fn ->
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})

	assert results = json_response(conn, 200)

	[] = results["statuses"]
	end)
	end

	test "search fetches remote accounts", %{conn: conn} do
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})

	assert results = json_response(conn, 200)
	[account] = results["accounts"]
	assert account["acct"] == "shp@social.heldscal.la"
	end

	test "returns the favorites of a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})

	{:ok, _, _} = CommonAPI.favorite(activity.id, user)

	first_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites")

	assert [status] = json_response(first_conn, 200)
	assert status["id"] == to_string(activity.id)

	assert [{"link", _link_header}] =
	Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)

	# Honours query params
	{:ok, second_activity} =
	CommonAPI.post(other_user, %{
	"status" =>
	"Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
	})

	{:ok, _, _} = CommonAPI.favorite(second_activity.id, user)

	last_like = status["id"]

	second_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?since_id=#{last_like}")

	assert [second_status] = json_response(second_conn, 200)
	assert second_status["id"] == to_string(second_activity.id)

	third_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?limit=0")

	assert [] = json_response(third_conn, 200)
	end

	describe "updating credentials" do
	test "updates the user's bio", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"note" => "I drink #cofe with @#{user2.nickname}"
	})

	assert user = json_response(conn, 200)

	assert user["note"] ==
	~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe" rel="tag">#cofe</a> with <span class="h-card"><a data-user=") <>
	user2.id <>
	~s(" class="u-url mention" href=") <>
	user2.ap_id <> ~s(">@<span>) <> user2.nickname <> ~s(</span></a></span>)
	end

	test "updates the user's locking status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user = json_response(conn, 200)
	assert user["locked"] == true
	end

	test "updates the user's name", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user = json_response(conn, 200)
	assert user["display_name"] == "markorepairs"
	end

	test "updates the user's avatar", %{conn: conn} do
	user = insert(:user)

	new_avatar = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response(conn, 200)
	assert user_response["avatar"] != User.avatar_url(user)
	end

	test "updates the user's banner", %{conn: conn} do
	user = insert(:user)

	new_header = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response(conn, 200)
	assert user_response["header"] != User.banner_url(user)
	end

	test "requires 'write' permission", %{conn: conn} do
	token1 = insert(:oauth_token, scopes: ["read"])
	token2 = insert(:oauth_token, scopes: ["write", "follow"])

	for token <- [token1, token2] do
	conn =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> patch("/api/v1/accounts/update_credentials", %{})

	if token == token1 do
	assert %{"error" => "Insufficient permissions: write."} == json_response(conn, 403)
	else
	assert json_response(conn, 200)
	end
	end
	end
	end

	test "get instance information", %{conn: conn} do
	conn = get(conn, "/api/v1/instance")
	assert result = json_response(conn, 200)

	# Note: not checking for "max_toot_chars" since it's optional
	assert %{
	"uri" => _,
	"title" => _,
	"description" => _,
	"version" => _,
	"email" => _,
	"urls" => %{
	"streaming_api" => _
	},
	"stats" => _,
	"thumbnail" => _,
	"languages" => _,
	"registrations" => _
	} = result
	end

	test "get instance stats", %{conn: conn} do
	user = insert(:user, %{local: true})

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	# Stats should count users with missing or nil `info.deactivated` value
	user = User.get_by_id(user.id)
	info_change = Changeset.change(user.info, %{deactivated: nil})

	{:ok, _user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> User.update_and_set_cache()

	Pleroma.Stats.update_stats()

	conn = get(conn, "/api/v1/instance")

	assert result = json_response(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	Pleroma.Stats.update_stats()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end

	test "put settings", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})

	assert _result = json_response(conn, 200)

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.info.settings == %{"programming" => "socks"}
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})

	[user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)

	id_str = to_string(activity.id)

	assert [%{"id" => ^id_str, "pinned" => true}] = result
	end

	test "pin status", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(200)

	assert [%{"id" => ^id_str, "pinned" => true}] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "unpin status", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "pinned" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response(200)

	assert [] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	id_str_one = to_string(activity_one.id)

	assert %{"id" => ^id_str_one, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{id_str_one}/pin")
	\|> json_response(200)

	user = refresh_record(user)

	assert %{"error" => "You have already pinned the maximum number of statuses"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity_two.id}/pin")
	\|> json_response(400)
	end

	test "Status rich-media Card", %{conn: conn, user: user} do
	Pleroma.Config.put([:rich_media, :enabled], true)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(200)

	assert response == %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"provider_name" => "www.imdb.com",
	"provider_url" => "http://www.imdb.com",
	"title" => "The Rock",
	"type" => "link",
	"url" => "http://www.imdb.com/title/tt0117500/",
	"description" => nil,
	"pleroma" => %{
	"opengraph" => %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock",
	"type" => "video.movie",
	"url" => "http://www.imdb.com/title/tt0117500/"
	}
	}
	}

	# works with private posts
	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "http://example.com/ogp", "visibility" => "direct"})

	response_two =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(200)

	assert response_two == response

	Pleroma.Config.put([:rich_media, :enabled], false)
	end
	end

	test "bookmarks" do
	user = insert(:user)
	for_user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(user, %{
	"status" => "heweoo?"
	})

	{:ok, activity2} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	response1 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity1.id}/bookmark")

	assert json_response(response1, 200)["bookmarked"] == true

	response2 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity2.id}/bookmark")

	assert json_response(response2, 200)["bookmarked"] == true

	bookmarks =
	build_conn()
	\|> assign(:user, for_user)
	\|> get("/api/v1/bookmarks")

	assert [json_response(response2, 200), json_response(response1, 200)] ==
	json_response(bookmarks, 200)

	response1 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity1.id}/unbookmark")

	assert json_response(response1, 200)["bookmarked"] == false

	bookmarks =
	build_conn()
	\|> assign(:user, for_user)
	\|> get("/api/v1/bookmarks")

	assert [json_response(response2, 200)] == json_response(bookmarks, 200)
	end

	describe "conversation muting" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HIE"})

	[user: user, activity: activity]
	end

	test "mute conversation", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/mute")
	\|> json_response(200)
	end

	test "unmute conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "muted" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unmute")
	\|> json_response(200)
	end
	end

	test "flavours switching (Pleroma Extension)", %{conn: conn} do
	user = insert(:user)

	get_old_flavour =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/pleroma/flavour")

	assert "glitch" == json_response(get_old_flavour, 200)

	set_flavour =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/flavour/vanilla")

	assert "vanilla" == json_response(set_flavour, 200)

	get_new_flavour =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/flavour/vanilla")

	assert json_response(set_flavour, 200) == json_response(get_new_flavour, 200)
	end

	describe "reports" do
	setup do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})

	[reporter: reporter, target_user: target_user, activity: activity]
	end

	test "submit a basic report", %{conn: conn, reporter: reporter, target_user: target_user} do
	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"account_id" => target_user.id})
	\|> json_response(200)
	end

	test "submit a report with statuses and comment", %{
	conn: conn,
	reporter: reporter,
	target_user: target_user,
	activity: activity
	} do
	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{
	"account_id" => target_user.id,
	"status_ids" => [activity.id],
	"comment" => "bad status!"
	})
	\|> json_response(200)
	end

	test "account_id is required", %{
	conn: conn,
	reporter: reporter,
	activity: activity
	} do
	assert %{"error" => "Valid `account_id` required"} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"status_ids" => [activity.id]})
	\|> json_response(400)
	end

	test "comment must be up to the size specified in the config", %{
	conn: conn,
	reporter: reporter,
	target_user: target_user
	} do
	max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
	comment = String.pad_trailing("a", max_size + 1, "a")

	error = %{"error" => "Comment must be up to #{max_size} characters"}

	assert ^error =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"account_id" => target_user.id, "comment" => comment})
	\|> json_response(400)
	end
	end

	describe "link headers" do
	test "preserves parameters in link headers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(other_user, %{
	"status" => "hi @#{user.nickname}",
	"visibility" => "public"
	})

	{:ok, activity2} =
	CommonAPI.post(other_user, %{
	"status" => "hi @#{user.nickname}",
	"visibility" => "public"
	})

	notification1 = Repo.get_by(Notification, activity_id: activity1.id)
	notification2 = Repo.get_by(Notification, activity_id: activity2.id)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications", %{media_only: true})

	assert [link_header] = get_resp_header(conn, "link")
	assert link_header =~ ~r/media_only=true/
	assert link_header =~ ~r/since_id=#{notification2.id}/
	assert link_header =~ ~r/max_id=#{notification1.id}/
	end
	end

	test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
	# Need to set an old-style integer ID to reproduce the problem
	# (these are no longer assigned to new accounts but were preserved
	# for existing accounts during the migration to flakeIDs)
	user_one = insert(:user, %{id: 1212})
	user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})

	resp_one =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}")

	resp_two =
	conn
	\|> get("/api/v1/accounts/#{user_two.nickname}")

	resp_three =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}")

	acc_one = json_response(resp_one, 200)
	acc_two = json_response(resp_two, 200)
	acc_three = json_response(resp_three, 200)
	refute acc_one == acc_two
	assert acc_two == acc_three
	end

	+ describe "custom emoji" do
	+ test "with tags", %{conn: conn} do
	+ [emoji \| _body] =
	+ conn
	+ \|> get("/api/v1/custom_emojis")
	+ \|> json_response(200)
	+
	+ assert Map.has_key?(emoji, "shortcode")
	+ assert Map.has_key?(emoji, "static_url")
	+ assert Map.has_key?(emoji, "tags")
	+ assert is_list(emoji["tags"])
	+ assert Map.has_key?(emoji, "url")
	+ assert Map.has_key?(emoji, "visible_in_picker")
	+ end
	+ end
	+
	describe "index/2 redirections" do
	setup %{conn: conn} do
	session_opts = [
	store: :cookie,
	key: "_test",
	signing_salt: "cooldude"
	]

	conn =
	conn
	\|> Plug.Session.call(Plug.Session.init(session_opts))
	\|> fetch_session()

	test_path = "/web/statuses/test"
	%{conn: conn, path: test_path}
	end

	test "redirects not logged-in users to the login page", %{conn: conn, path: path} do
	conn = get(conn, path)

	assert conn.status == 302
	assert redirected_to(conn) == "/web/login"
	end

	test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
	token = insert(:oauth_token)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> put_session(:oauth_token, token.token)
	\|> get(path)

	assert conn.status == 200
	end

	test "saves referer path to session", %{conn: conn, path: path} do
	conn = get(conn, path)
	return_to = Plug.Conn.get_session(conn, :return_to)

	assert return_to == path
	end

	test "redirects to the saved path after log in", %{conn: conn, path: path} do
	app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
	auth = insert(:oauth_authorization, app: app)

	conn =
	conn
	\|> put_session(:return_to, path)
	\|> get("/web/login", %{code: auth.token})

	assert conn.status == 302
	assert redirected_to(conn) == path
	end

	test "redirects to the getting-started page when referer is not present", %{conn: conn} do
	app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
	auth = insert(:oauth_authorization, app: app)

	conn = get(conn, "/web/login", %{code: auth.token})

	assert conn.status == 302
	assert redirected_to(conn) == "/web/getting-started"
	end
	end

	describe "scheduled activities" do
	test "creates a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
	assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(scheduled_at)
	assert [] == Repo.all(Activity)
	end

	test "creates a scheduled activity with a media attachment", %{conn: conn} do
	user = insert(:user)
	scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)],
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
	assert %{"type" => "image"} = media_attachment
	end

	test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
	%{conn: conn} do
	user = insert(:user)

	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "not scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"content" => "not scheduled"} = json_response(conn, 200)
	assert [] == Repo.all(ScheduledActivity)
	end

	test "returns error when daily user limit is exceeded", %{conn: conn} do
	user = insert(:user)

	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})

	assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
	end

	test "returns error when total user limit is exceeded", %{conn: conn} do
	user = insert(:user)

	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	tomorrow =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.hours(36), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})

	assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
	end

	test "shows scheduled activities", %{conn: conn} do
	user = insert(:user)
	scheduled_activity_id1 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id2 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id3 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id4 = insert(:scheduled_activity, user: user).id \|> to_string()

	conn =
	conn
	\|> assign(:user, user)

	# min_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&min_id=#{scheduled_activity_id1}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result

	# since_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&since_id=#{scheduled_activity_id1}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id4}, %{"id" => ^scheduled_activity_id3}] = result

	# max_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&max_id=#{scheduled_activity_id4}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
	end

	test "shows a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{"id" => scheduled_activity_id} = json_response(res_conn, 200)
	assert scheduled_activity_id == scheduled_activity.id \|> to_string()

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/scheduled_statuses/404")

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end

	test "updates a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	new_scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/scheduled_statuses/#{scheduled_activity.id}", %{
	scheduled_at: new_scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} = json_response(res_conn, 200)
	assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(new_scheduled_at)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/scheduled_statuses/404", %{scheduled_at: new_scheduled_at})

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end

	test "deletes a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{} = json_response(res_conn, 200)
	assert nil == Repo.get(ScheduledActivity, scheduled_activity.id)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end
	end
	end
	diff --git a/test/web/oauth/oauth_controller_test.exs b/test/web/oauth/oauth_controller_test.exs
	index 3d556e32f..bc971a574 100644
	--- a/test/web/oauth/oauth_controller_test.exs
	+++ b/test/web/oauth/oauth_controller_test.exs
	@@ -1,445 +1,751 @@
	# 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.OAuthControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory
	+ import Mock

	+ alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.Web.Auth.TOTP
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

	- describe "GET /oauth/authorize" do
	+ @session_opts [
	+ store: :cookie,
	+ key: "_test",
	+ signing_salt: "cooldude"
	+ ]
	+
	+ describe "in OAuth consumer mode, " do
	setup do
	- session_opts = [
	- store: :cookie,
	- key: "_test",
	- signing_salt: "cooldude"
	+ oauth_consumer_strategies_path = [:auth, :oauth_consumer_strategies]
	+ oauth_consumer_strategies = Pleroma.Config.get(oauth_consumer_strategies_path)
	+ Pleroma.Config.put(oauth_consumer_strategies_path, ~w(twitter facebook))
	+
	+ on_exit(fn ->
	+ Pleroma.Config.put(oauth_consumer_strategies_path, oauth_consumer_strategies)
	+ end)
	+
	+ [
	+ app: insert(:oauth_app),
	+ conn:
	+ build_conn()
	+ \|> Plug.Session.call(Plug.Session.init(@session_opts))
	+ \|> fetch_session()
	]
	+ end
	+
	+ test "GET /oauth/authorize renders auth forms, including OAuth consumer form", %{
	+ app: app,
	+ conn: conn
	+ } do
	+ conn =
	+ get(
	+ conn,
	+ "/oauth/authorize",
	+ %{
	+ "response_type" => "code",
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "scope" => "read"
	+ }
	+ )
	+
	+ assert response = html_response(conn, 200)
	+ assert response =~ "Sign in with Twitter"
	+ assert response =~ o_auth_path(conn, :prepare_request)
	+ end

	+ test "GET /oauth/prepare_request encodes parameters as `state` and redirects", %{
	+ app: app,
	+ conn: conn
	+ } do
	+ conn =
	+ get(
	+ conn,
	+ "/oauth/prepare_request",
	+ %{
	+ "provider" => "twitter",
	+ "scope" => "read follow",
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state"
	+ }
	+ )
	+
	+ assert response = html_response(conn, 302)
	+
	+ redirect_query = URI.parse(redirected_to(conn)).query
	+ assert %{"state" => state_param} = URI.decode_query(redirect_query)
	+ assert {:ok, state_components} = Poison.decode(state_param)
	+
	+ expected_client_id = app.client_id
	+ expected_redirect_uri = app.redirect_uris
	+
	+ assert %{
	+ "scope" => "read follow",
	+ "client_id" => ^expected_client_id,
	+ "redirect_uri" => ^expected_redirect_uri,
	+ "state" => "a_state"
	+ } = state_components
	+ end
	+
	+ test "with user-bound registration, GET /oauth/<provider>/callback redirects to `redirect_uri` with `code`",
	+ %{app: app, conn: conn} do
	+ registration = insert(:registration)
	+
	+ state_params = %{
	+ "scope" => Enum.join(app.scopes, " "),
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => ""
	+ }
	+
	+ with_mock Pleroma.Web.Auth.Authenticator,
	+ get_registration: fn _, _ -> {:ok, registration} end do
	+ conn =
	+ get(
	+ conn,
	+ "/oauth/twitter/callback",
	+ %{
	+ "oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	+ "oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	+ "provider" => "twitter",
	+ "state" => Poison.encode!(state_params)
	+ }
	+ )
	+
	+ assert response = html_response(conn, 302)
	+ assert redirected_to(conn) =~ ~r/#{app.redirect_uris}\?code=.+/
	+ end
	+ end
	+
	+ test "with user-unbound registration, GET /oauth/<provider>/callback renders registration_details page",
	+ %{app: app, conn: conn} do
	+ registration = insert(:registration, user: nil)
	+
	+ state_params = %{
	+ "scope" => "read write",
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state"
	+ }
	+
	+ with_mock Pleroma.Web.Auth.Authenticator,
	+ get_registration: fn _, _ -> {:ok, registration} end do
	+ conn =
	+ get(
	+ conn,
	+ "/oauth/twitter/callback",
	+ %{
	+ "oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	+ "oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	+ "provider" => "twitter",
	+ "state" => Poison.encode!(state_params)
	+ }
	+ )
	+
	+ assert response = html_response(conn, 200)
	+ assert response =~ ~r/name="op" type="submit" value="register"/
	+ assert response =~ ~r/name="op" type="submit" value="connect"/
	+ assert response =~ Registration.email(registration)
	+ assert response =~ Registration.nickname(registration)
	+ end
	+ end
	+
	+ test "on authentication error, GET /oauth/<provider>/callback redirects to `redirect_uri`", %{
	+ app: app,
	+ conn: conn
	+ } do
	+ state_params = %{
	+ "scope" => Enum.join(app.scopes, " "),
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => ""
	+ }
	+
	+ conn =
	+ conn
	+ \|> assign(:ueberauth_failure, %{errors: [%{message: "(error description)"}]})
	+ \|> get(
	+ "/oauth/twitter/callback",
	+ %{
	+ "oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	+ "oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	+ "provider" => "twitter",
	+ "state" => Poison.encode!(state_params)
	+ }
	+ )
	+
	+ assert response = html_response(conn, 302)
	+ assert redirected_to(conn) == app.redirect_uris
	+ assert get_flash(conn, :error) == "Failed to authenticate: (error description)."
	+ end
	+
	+ test "GET /oauth/registration_details renders registration details form", %{
	+ app: app,
	+ conn: conn
	+ } do
	+ conn =
	+ get(
	+ conn,
	+ "/oauth/registration_details",
	+ %{
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "nickname" => nil,
	+ "email" => "john@doe.com"
	+ }
	+ )
	+
	+ assert response = html_response(conn, 200)
	+ assert response =~ ~r/name="op" type="submit" value="register"/
	+ assert response =~ ~r/name="op" type="submit" value="connect"/
	+ end
	+
	+ test "with valid params, POST /oauth/register?op=register redirects to `redirect_uri` with `code`",
	+ %{
	+ app: app,
	+ conn: conn
	+ } do
	+ registration = insert(:registration, user: nil, info: %{"nickname" => nil, "email" => nil})
	+
	+ conn =
	+ conn
	+ \|> put_session(:registration_id, registration.id)
	+ \|> post(
	+ "/oauth/register",
	+ %{
	+ "op" => "register",
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "nickname" => "availablenick",
	+ "email" => "available@email.com"
	+ }
	+ )
	+
	+ assert response = html_response(conn, 302)
	+ assert redirected_to(conn) =~ ~r/#{app.redirect_uris}\?code=.+/
	+ end
	+
	+ test "with invalid params, POST /oauth/register?op=register renders registration_details page",
	+ %{
	+ app: app,
	+ conn: conn
	+ } do
	+ another_user = insert(:user)
	+ registration = insert(:registration, user: nil, info: %{"nickname" => nil, "email" => nil})
	+
	+ params = %{
	+ "op" => "register",
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "nickname" => "availablenickname",
	+ "email" => "available@email.com"
	+ }
	+
	+ for {bad_param, bad_param_value} <-
	+ [{"nickname", another_user.nickname}, {"email", another_user.email}] do
	+ bad_params = Map.put(params, bad_param, bad_param_value)
	+
	+ conn =
	+ conn
	+ \|> put_session(:registration_id, registration.id)
	+ \|> post("/oauth/register", bad_params)
	+
	+ assert html_response(conn, 403) =~ ~r/name="op" type="submit" value="register"/
	+ assert get_flash(conn, :error) == "Error: #{bad_param} has already been taken."
	+ end
	+ end
	+
	+ test "with valid params, POST /oauth/register?op=connect redirects to `redirect_uri` with `code`",
	+ %{
	+ app: app,
	+ conn: conn
	+ } do
	+ user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt("testpassword"))
	+ registration = insert(:registration, user: nil)
	+
	+ conn =
	+ conn
	+ \|> put_session(:registration_id, registration.id)
	+ \|> post(
	+ "/oauth/register",
	+ %{
	+ "op" => "connect",
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "auth_name" => user.nickname,
	+ "password" => "testpassword"
	+ }
	+ )
	+
	+ assert response = html_response(conn, 302)
	+ assert redirected_to(conn) =~ ~r/#{app.redirect_uris}\?code=.+/
	+ end
	+
	+ test "with invalid params, POST /oauth/register?op=connect renders registration_details page",
	+ %{
	+ app: app,
	+ conn: conn
	+ } do
	+ user = insert(:user)
	+ registration = insert(:registration, user: nil)
	+
	+ params = %{
	+ "op" => "connect",
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "auth_name" => user.nickname,
	+ "password" => "wrong password"
	+ }
	+
	+ conn =
	+ conn
	+ \|> put_session(:registration_id, registration.id)
	+ \|> post("/oauth/register", params)
	+
	+ assert html_response(conn, 401) =~ ~r/name="op" type="submit" value="connect"/
	+ assert get_flash(conn, :error) == "Invalid Username/Password"
	+ end
	+ end
	+
	+ describe "GET /oauth/authorize" do
	+ setup do
	[
	app: insert(:oauth_app, redirect_uris: "https://redirect.url"),
	conn:
	build_conn()
	- \|> Plug.Session.call(Plug.Session.init(session_opts))
	+ \|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session()
	]
	end

	test "renders authentication page", %{app: app, conn: conn} do
	conn =
	get(
	conn,
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read"
	}
	)

	assert html_response(conn, 200) =~ ~s(type="submit")
	end

	test "renders authentication page if user is already authenticated but `force_login` is tru-ish",
	%{app: app, conn: conn} do
	token = insert(:oauth_token, app_id: app.id)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read",
	"force_login" => "true"
	}
	)

	assert html_response(conn, 200) =~ ~s(type="submit")
	end

	test "redirects to app if user is already authenticated", %{app: app, conn: conn} do
	token = insert(:oauth_token, app_id: app.id)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read"
	}
	)

	assert redirected_to(conn) == "https://redirect.url"
	end
	end

	describe "POST /oauth/authorize" do
	test "redirects with oauth authorization" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write", "follow"])

	conn =
	build_conn()
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read write",
	"state" => "statepassed"
	}
	})

	target = redirected_to(conn)
	assert target =~ app.redirect_uris

	query = URI.parse(target).query \|> URI.query_decoder() \|> Map.new()

	assert %{"state" => "statepassed", "code" => code} = query
	auth = Repo.get_by(Authorization, token: code)
	assert auth
	assert auth.scopes == ["read", "write"]
	end

	test "returns 401 for wrong credentials", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app)

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "wrong",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "statepassed",
	"scope" => Enum.join(app.scopes, " ")
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ app.redirect_uris

	# Error message
	assert result =~ "Invalid Username/Password"
	end

	test "returns 401 for missing scopes", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app)

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "statepassed",
	"scope" => ""
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ app.redirect_uris

	# Error message
	assert result =~ "This action is outside the authorized scopes"
	end

	test "returns 401 for scopes beyond app scopes", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "statepassed",
	"scope" => "read write follow"
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ app.redirect_uris

	# Error message
	assert result =~ "This action is outside the authorized scopes"
	end
	end

	describe "POST /oauth/token" do
	test "issues a token for an all-body request" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["write"])

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token, "me" => ap_id} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == auth.scopes
	assert user.ap_id == ap_id
	end

	test "issues a token for `password` grant_type with valid credentials, with full permissions by default" do
	password = "testpassword"
	user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))

	app = insert(:oauth_app, scopes: ["read", "write"])

	# Note: "scope" param is intentionally omitted
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == app.scopes
	end

	test "issues a token for request with HTTP basic auth client credentials" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["scope1", "scope2", "scope3"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["scope1", "scope2"])
	assert auth.scopes == ["scope1", "scope2"]

	app_encoded =
	(URI.encode_www_form(app.client_id) <> ":" <> URI.encode_www_form(app.client_secret))
	\|> Base.encode64()

	conn =
	build_conn()
	\|> put_req_header("authorization", "Basic " <> app_encoded)
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris
	})

	assert %{"access_token" => token, "scope" => scope} = json_response(conn, 200)

	assert scope == "scope1 scope2"

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == ["scope1", "scope2"]
	end

	test "rejects token exchange with invalid client credentials" do
	user = insert(:user)
	app = insert(:oauth_app)

	{:ok, auth} = Authorization.create_authorization(app, user)

	conn =
	build_conn()
	\|> put_req_header("authorization", "Basic JTIxOiVGMCU5RiVBNCVCNwo=")
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris
	})

	assert resp = json_response(conn, 400)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects token exchange for valid credentials belonging to unconfirmed user and confirmation is required" 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

	password = "testpassword"
	user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
	info_change = Pleroma.User.Info.confirmation_changeset(user.info, :unconfirmed)

	{:ok, user} =
	user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, info_change)
	\|> Repo.update()

	refute Pleroma.User.auth_active?(user)

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 403)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects token exchange for valid credentials belonging to deactivated user" do
	password = "testpassword"

	user =
	insert(:user,
	password_hash: Comeonin.Pbkdf2.hashpwsalt(password),
	info: %{deactivated: true}
	)

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 403)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects an invalid authorization code" do
	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => "Imobviouslyinvalid",
	"redirect_uri" => app.redirect_uris,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 400)
	assert %{"error" => _} = json_response(conn, 400)
	refute Map.has_key?(resp, "access_token")
	end
	end

	describe "2fa" do
	test "issues a token for `password` grant_type with valid credentials and backup code" do
	password = "testpassword"
	otp_secret = Pleroma.Web.Auth.TOTP.generate_secret()

	user =
	insert(:user,
	otp_enabled: true,
	otp_secret: otp_secret,
	password_hash: Comeonin.Pbkdf2.hashpwsalt(password)
	)

	[code \| _] = backup_codes = Pleroma.Web.Auth.TOTP.generate_backup_codes()

	[_ \| unused_codes] =
	hashed_codes =
	backup_codes
	\|> Enum.map(&Comeonin.Pbkdf2.hashpwsalt(&1))

	Pleroma.User.update_2fa_backup_codes(user, hashed_codes)

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret,
	"otp_token" => code
	})

	assert %{"access_token" => token} = json_response(conn, 200)
	assert Repo.get_by(Token, token: token)
	user = refresh_record(user)
	assert user.otp_backup_codes == unused_codes
	end

	test "issues a token for `password` grant_type with valid credentials" do
	password = "testpassword"
	otp_secret = TOTP.generate_secret()

	user =
	insert(:user,
	otp_enabled: true,
	otp_secret: otp_secret,
	password_hash: Comeonin.Pbkdf2.hashpwsalt(password)
	)

	app = insert(:oauth_app)
	otp_token = TOTP.generate_token(otp_secret)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret,
	"otp_token" => otp_token
	})

	assert %{"access_token" => token} = json_response(conn, 200)
	assert Repo.get_by(Token, token: token)
	end
	end
	end
	diff --git a/test/web/push/impl_test.exs b/test/web/push/impl_test.exs
	index 3f9f3d809..6bac2c9f6 100644
	--- a/test/web/push/impl_test.exs
	+++ b/test/web/push/impl_test.exs
	@@ -1,145 +1,147 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.ImplTest do
	use Pleroma.DataCase

	alias Pleroma.Web.Push.Impl
	alias Pleroma.Web.Push.Subscription

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn
	%{method: :post, url: "https://example.com/example/1234"} ->
	%Tesla.Env{status: 200}

	%{method: :post, url: "https://example.com/example/not_found"} ->
	%Tesla.Env{status: 400}

	%{method: :post, url: "https://example.com/example/bad"} ->
	%Tesla.Env{status: 100}
	end)

	:ok
	end

	@sub %{
	endpoint: "https://example.com/example/1234",
	keys: %{
	auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA="
	}
	}
	@api_key "BASgACIHpN1GYgzSRp"
	@message "@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	test "performs sending notifications" do
	user = insert(:user)
	user2 = insert(:user)
	insert(:push_subscription, user: user, data: %{alerts: %{"mention" => true}})
	insert(:push_subscription, user: user2, data: %{alerts: %{"mention" => true}})

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => true}}
	)

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => false}}
	)

	notif =
	insert(:notification,
	user: user,
	activity: %Pleroma.Activity{
	data: %{
	"type" => "Create",
	"actor" => user.ap_id,
	"object" => %{"content" => "<Lorem ipsum dolor sit amet."}
	}
	}
	)

	- assert Impl.perform_send(notif) == [:ok, :ok]
	+ assert Impl.perform(notif) == [:ok, :ok]
	end

	+ @tag capture_log: true
	test "returns error if notif does not match " do
	- assert Impl.perform_send(%{}) == :error
	+ assert Impl.perform(%{}) == :error
	end

	test "successful message sending" do
	assert Impl.push_message(@message, @sub, @api_key, %Subscription{}) == :ok
	end

	+ @tag capture_log: true
	test "fail message sending" do
	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/bad"}),
	@api_key,
	%Subscription{}
	) == :error
	end

	test "delete subsciption if restult send message between 400..500" do
	subscription = insert(:push_subscription)

	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/not_found"}),
	@api_key,
	subscription
	) == :ok

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "renders body for create activity" do
	assert Impl.format_body(
	%{
	activity: %{
	data: %{
	"type" => "Create",
	"object" => %{
	"content" =>
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :bear: adipiscing elit. Fusce sagittis finibus turpis."
	}
	}
	}
	},
	%{nickname: "Bob"}
	) ==
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."
	end

	test "renders body for follow activity" do
	assert Impl.format_body(%{activity: %{data: %{"type" => "Follow"}}}, %{nickname: "Bob"}) ==
	"@Bob has followed you"
	end

	test "renders body for announce activity" do
	user = insert(:user)

	note =
	insert(:note, %{
	data: %{
	"content" =>
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :bear: adipiscing elit. Fusce sagittis finibus turpis."
	}
	})

	note_activity = insert(:note_activity, %{note: note})
	announce_activity = insert(:announce_activity, %{user: user, note_activity: note_activity})

	assert Impl.format_body(%{activity: announce_activity}, user) ==
	"@#{user.nickname} repeated: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."
	end

	test "renders body for like activity" do
	assert Impl.format_body(%{activity: %{data: %{"type" => "Like"}}}, %{nickname: "Bob"}) ==
	"@Bob has favorited your post"
	end
	end
	diff --git a/test/web/twitter_api/util_controller_test.exs b/test/web/twitter_api/util_controller_test.exs
	index e4dd97d46..410f20f87 100644
	--- a/test/web/twitter_api/util_controller_test.exs
	+++ b/test/web/twitter_api/util_controller_test.exs
	@@ -1,194 +1,215 @@
	defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory

	setup do
	Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "POST /api/pleroma/follow_import" do
	test "it returns HTTP 200", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/follow_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response(:ok)

	assert response == "job started"
	end

	test "requires 'follow' permission", %{conn: conn} do
	token1 = insert(:oauth_token, scopes: ["read", "write"])
	token2 = insert(:oauth_token, scopes: ["follow"])
	another_user = insert(:user)

	for token <- [token1, token2] do
	conn =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> post("/api/pleroma/follow_import", %{"list" => "#{another_user.ap_id}"})

	if token == token1 do
	assert %{"error" => "Insufficient permissions: follow."} == json_response(conn, 403)
	else
	assert json_response(conn, 200)
	end
	end
	end
	end

	describe "POST /api/pleroma/blocks_import" do
	test "it returns HTTP 200", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/blocks_import", %{"list" => "#{user2.ap_id}"})
	\|> json_response(:ok)

	assert response == "job started"
	end
	end

	describe "POST /api/pleroma/notifications/read" do
	test "it marks a single notification as read", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, activity1} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"})
	{:ok, activity2} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"})
	{:ok, [notification1]} = Notification.create_notifications(activity1)
	{:ok, [notification2]} = Notification.create_notifications(activity2)

	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/notifications/read", %{"id" => "#{notification1.id}"})
	\|> json_response(:ok)

	assert Repo.get(Notification, notification1.id).seen
	refute Repo.get(Notification, notification2.id).seen
	end
	end

	describe "GET /api/statusnet/config.json" do
	test "returns the state of safe_dm_mentions flag", %{conn: conn} do
	option = Pleroma.Config.get([:instance, :safe_dm_mentions])
	Pleroma.Config.put([:instance, :safe_dm_mentions], true)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["safeDMMentionsEnabled"] == "1"

	Pleroma.Config.put([:instance, :safe_dm_mentions], false)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["safeDMMentionsEnabled"] == "0"

	Pleroma.Config.put([:instance, :safe_dm_mentions], option)
	end

	test "it returns the managed config", %{conn: conn} do
	Pleroma.Config.put([:instance, :managed_config], false)
	Pleroma.Config.put([:fe], theme: "rei-ayanami-towel")

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	refute response["site"]["pleromafe"]

	Pleroma.Config.put([:instance, :managed_config], true)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["pleromafe"]
	end

	test "if :pleroma, :fe is false, it returns the new style config settings", %{conn: conn} do
	Pleroma.Config.put([:instance, :managed_config], true)
	Pleroma.Config.put([:fe, :theme], "rei-ayanami-towel")
	Pleroma.Config.put([:frontend_configurations, :pleroma_fe], %{theme: "asuka-hospital"})

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["pleromafe"]["theme"] == "rei-ayanami-towel"

	Pleroma.Config.put([:fe], false)

	response =
	conn
	\|> get("/api/statusnet/config.json")
	\|> json_response(:ok)

	assert response["site"]["pleromafe"]["theme"] == "asuka-hospital"
	end
	end

	describe "GET /api/pleroma/frontend_configurations" do
	test "returns everything in :pleroma, :frontend_configurations", %{conn: conn} do
	config = [
	frontend_a: %{
	x: 1,
	y: 2
	},
	frontend_b: %{
	z: 3
	}
	]

	Pleroma.Config.put(:frontend_configurations, config)

	response =
	conn
	\|> get("/api/pleroma/frontend_configurations")
	\|> json_response(:ok)

	assert response == Jason.encode!(config \|> Enum.into(%{})) \|> Jason.decode!()
	end
	end

	+ describe "/api/pleroma/emoji" do
	+ test "returns json with custom emoji with tags", %{conn: conn} do
	+ [emoji \| _body] =
	+ conn
	+ \|> get("/api/pleroma/emoji")
	+ \|> json_response(200)
	+
	+ [key] = Map.keys(emoji)
	+
	+ %{
	+ ^key => %{
	+ "image_url" => url,
	+ "tags" => tags
	+ }
	+ } = emoji
	+
	+ assert is_binary(url)
	+ assert is_list(tags)
	+ end
	+ end
	+
	describe "GET /ostatus_subscribe?acct=...." do
	test "adds status to pleroma instance if the `acct` is a status", %{conn: conn} do
	conn =
	get(
	conn,
	"/ostatus_subscribe?acct=https://mastodon.social/users/emelie/statuses/101849165031453009"
	)

	assert redirected_to(conn) =~ "/notice/"
	end

	test "show follow account page if the `acct` is a account link", %{conn: conn} do
	response =
	get(
	conn,
	"/ostatus_subscribe?acct=https://mastodon.social/users/emelie"
	)

	assert html_response(response, 200) =~ "Log in to follow"
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 3:07 AM (6 h, 46 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1797458
Default Alt Text: (550 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions