No OneTemporary
Actions

Size

546 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/config/config.exs b/config/config.exs
	index cdbce6504..3462a37f7 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,426 +1,427 @@
	# 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"],
	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

	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/docs/api/admin_api.md b/docs/api/admin_api.md
	index 86cacebb1..8befa8ea0 100644
	--- a/docs/api/admin_api.md
	+++ b/docs/api/admin_api.md
	@@ -1,224 +1,277 @@
	# Admin API

	Authentication is required and the user must be an admin.

	## `/api/pleroma/admin/users`

	### List users

	- Method `GET`
	- Query Params:
	- optional `query`: string search term
	- optional `filters`: string comma-separated string of filters:
	- `local`: only local users
	- `external`: only external users
	- `active`: only active users
	- `deactivated`: only deactivated users
	- optional `page`: integer page number
	- optional `page_size`: integer number of users per page (default is `50`)
	- Example: `https://mypleroma.org/api/pleroma/admin/users?query=john&filters=local,active&page=1&page_size=10`
	- Response:

	```JSON
	{
	"page_size": integer,
	"count": integer,
	"users": [
	{
	"deactivated": bool,
	"id": integer,
	"nickname": string,
	"roles": {
	"admin": bool,
	"moderator": bool
	},
	"local": bool,
	"tags": array
	},
	...
	]
	}
	```

	## `/api/pleroma/admin/user`

	### Remove a user

	- Method `DELETE`
	- Params:
	- `nickname`
	- Response: User’s nickname

	### Create a user

	- Method: `POST`
	- Params:
	- `nickname`
	- `email`
	- `password`
	- Response: User’s nickname

	## `/api/pleroma/admin/user/follow`
	### Make a user follow another user

	- Methods: `POST`
	- Params:
	- `follower`: The nickname of the follower
	- `followed`: The nickname of the followed
	- Response:
	- "ok"

	## `/api/pleroma/admin/user/unfollow`
	### Make a user unfollow another user

	- Methods: `POST`
	- Params:
	- `follower`: The nickname of the follower
	- `followed`: The nickname of the followed
	- Response:
	- "ok"

	## `/api/pleroma/admin/users/:nickname/toggle_activation`

	### Toggle user activation

	- Method: `PATCH`
	- Params:
	- `nickname`
	- Response: User’s object

	```JSON
	{
	"deactivated": bool,
	"id": integer,
	"nickname": string
	}
	```

	## `/api/pleroma/admin/users/tag`

	### Tag a list of users

	- Method: `PUT`
	- Params:
	- `nickname`
	- `tags`

	### Untag a list of users

	- Method: `DELETE`
	- Params:
	- `nickname`
	- `tags`

	## `/api/pleroma/admin/permission_group/:nickname`

	### Get user user permission groups membership

	- Method: `GET`
	- Params: none
	- Response:

	```JSON
	{
	"is_moderator": bool,
	"is_admin": bool
	}
	```

	## `/api/pleroma/admin/permission_group/:nickname/:permission_group`

	Note: Available `:permission_group` is currently moderator and admin. 404 is returned when the permission group doesn’t exist.

	### Get user user permission groups membership per permission group

	- Method: `GET`
	- Params: none
	- Response:

	```JSON
	{
	"is_moderator": bool,
	"is_admin": bool
	}
	```

	### Add user in permission group

	- Method: `POST`
	- Params: none
	- Response:
	- On failure: `{"error": "…"}`
	- On success: JSON of the `user.info`

	### Remove user from permission group

	- Method: `DELETE`
	- Params: none
	- Response:
	- On failure: `{"error": "…"}`
	- On success: JSON of the `user.info`
	- Note: An admin cannot revoke their own admin status.

	## `/api/pleroma/admin/activation_status/:nickname`

	### Active or deactivate a user

	- Method: `PUT`
	- Params:
	- `nickname`
	- `status` BOOLEAN field, false value means deactivation.

	## `/api/pleroma/admin/users/:nickname`

	### Retrive the details of a user

	- Method: `GET`
	- Params:
	- `nickname`
	- Response:
	- On failure: `Not found`
	- On success: JSON of the user

	## `/api/pleroma/admin/relay`

	### Follow a Relay

	- Methods: `POST`
	- Params:
	- `relay_url`
	- Response:
	- On success: URL of the followed relay

	### Unfollow a Relay

	- Methods: `DELETE`
	- Params:
	- `relay_url`
	- Response:
	- On success: URL of the unfollowed relay

	## `/api/pleroma/admin/invite_token`

	-### Get a account registeration invite token
	+### Get an account registration invite token

	- Methods: `GET`
	-- Params: none
	+- Params:
	+ - optional `invite` => [
	+ - optional `max_use` (integer)
	+ - optional `expires_at` (date string e.g. "2019-04-07")
	+ ]
	- Response: invite token (base64 string)

	+## `/api/pleroma/admin/invites`
	+
	+### Get a list of generated invites
	+
	+- Methods: `GET`
	+- Params: none
	+- Response:
	+
	+```JSON
	+{
	+
	+ "invites": [
	+ {
	+ "id": integer,
	+ "token": string,
	+ "used": boolean,
	+ "expires_at": date,
	+ "uses": integer,
	+ "max_use": integer,
	+ "invite_type": string (possible values: `one_time`, `reusable`, `date_limited`, `reusable_date_limited`)
	+ },
	+ ...
	+ ]
	+}
	+```
	+
	+## `/api/pleroma/admin/revoke_invite`
	+
	+### Revoke invite by token
	+
	+- Methods: `POST`
	+- Params:
	+ - `token`
	+- Response:
	+
	+```JSON
	+{
	+ "id": integer,
	+ "token": string,
	+ "used": boolean,
	+ "expires_at": date,
	+ "uses": integer,
	+ "max_use": integer,
	+ "invite_type": string (possible values: `one_time`, `reusable`, `date_limited`, `reusable_date_limited`)
	+
	+}
	+```
	+
	+
	## `/api/pleroma/admin/email_invite`

	### Sends registration invite via email

	- Methods: `POST`
	- Params:
	- `email`
	- - `name`, optionnal
	+ - `name`, optional

	## `/api/pleroma/admin/password_reset`

	### Get a password reset token for a given nickname

	- Methods: `GET`
	- Params: none
	- Response: password reset token (base64 string)
	diff --git a/docs/api/differences_in_mastoapi_responses.md b/docs/api/differences_in_mastoapi_responses.md
	index 215f43155..923d94db2 100644
	--- a/docs/api/differences_in_mastoapi_responses.md
	+++ b/docs/api/differences_in_mastoapi_responses.md
	@@ -1,52 +1,54 @@
	# Differences in Mastodon API responses from vanilla Mastodon

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

	## Flake IDs

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

	## Attachment cap

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

	## Timelines

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

	## Statuses

	Has these additional fields under the `pleroma` object:

	- `local`: true if the post was made on the local instance.
	- `conversation_id`: the ID of the conversation the status is associated with (if any)
	+- `content`: a map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`
	+- `spoiler_text`: a map consisting of alternate representations of the `spoiler_text` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`

	## Attachments

	Has these additional fields under the `pleroma` object:

	- `mime_type`: mime type of the attachment.

	## Accounts

	- `/api/v1/accounts/:id`: The `id` parameter can also be the `nickname` of the user. This only works in this endpoint, not the deeper nested ones for following etc.

	Has these additional fields under the `pleroma` object:

	- `tags`: Lists an array of tags for the user
	- `relationship{}`: Includes fields as documented for Mastodon API https://docs.joinmastodon.org/api/entities/#relationship
	- `is_moderator`: boolean, true if user is a moderator
	- `is_admin`: boolean, true if user is an admin
	- `confirmation_pending`: boolean, true if a new user account is waiting on email confirmation to be activated

	## Notifications

	Has these additional fields under the `pleroma` object:

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

	## POST `/api/v1/statuses`

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

	- `preview`: boolean, if set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example.
	diff --git a/docs/api/pleroma_api.md b/docs/api/pleroma_api.md
	index 2e8fb04d2..dbe250300 100644
	--- a/docs/api/pleroma_api.md
	+++ b/docs/api/pleroma_api.md
	@@ -1,118 +1,199 @@
	# 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":{"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"}}]`
	+* Example response:
	+```json
	+{
	+ "girlpower": {
	+ "tags": [
	+ "Finmoji"
	+ ],
	+ "image_url": "/finmoji/128px/girlpower-128.png"
	+ },
	+ "education": {
	+ "tags": [
	+ "Finmoji"
	+ ],
	+ "image_url": "/finmoji/128px/education-128.png"
	+ },
	+ "finnishlove": {
	+ "tags": [
	+ "Finmoji"
	+ ],
	+ "image_url": "/finmoji/128px/finnishlove-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.
	+ * `token`: invite token required when the registrations 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/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
	+ * `id`: notification's id
	* Response: JSON. Returns `{"status": "success"}` if the reading was successful, otherwise returns `{"error": "error_msg"}`
	+
	+## `/api/v1/pleroma/accounts/:id/subscribe`
	+### Subscribe to receive notifications for all statuses posted by a user
	+* Method `POST`
	+* Authentication: required
	+* Params:
	+ * `id`: account id to subscribe to
	+* Response: JSON, returns a mastodon relationship object on success, otherwise returns `{"error": "error_msg"}`
	+* Example response:
	+```json
	+{
	+ "id": "abcdefg",
	+ "following": true,
	+ "followed_by": false,
	+ "blocking": false,
	+ "muting": false,
	+ "muting_notifications": false,
	+ "subscribing": true,
	+ "requested": false,
	+ "domain_blocking": false,
	+ "showing_reblogs": true,
	+ "endorsed": false
	+}
	+```
	+
	+## `/api/v1/pleroma/accounts/:id/unsubscribe`
	+### Unsubscribe to stop receiving notifications from user statuses
	+* Method `POST`
	+* Authentication: required
	+* Params:
	+ * `id`: account id to unsubscribe from
	+* Response: JSON, returns a mastodon relationship object on success, otherwise returns `{"error": "error_msg"}`
	+* Example response:
	+```json
	+{
	+ "id": "abcdefg",
	+ "following": true,
	+ "followed_by": false,
	+ "blocking": false,
	+ "muting": false,
	+ "muting_notifications": false,
	+ "subscribing": false,
	+ "requested": false,
	+ "domain_blocking": false,
	+ "showing_reblogs": true,
	+ "endorsed": false
	+}
	+```
	+
	+## `/api/pleroma/notification_settings`
	+### Updates user notification settings
	+* Method `PUT`
	+* Authentication: required
	+* Params:
	+ * `followers`: BOOLEAN field, receives notifications from followers
	+ * `follows`: BOOLEAN field, receives notifications from people the user follows
	+ * `remote`: BOOLEAN field, receives notifications from people on remote instances
	+ * `local`: BOOLEAN field, receives notifications from people on the local instance
	+* Response: JSON. Returns `{"status": "success"}` if the update was successful, otherwise returns `{"error": "error_msg"}`
	diff --git a/docs/config.md b/docs/config.md
	index 7e7fa754a..b5ea58746 100644
	--- a/docs/config.md
	+++ b/docs/config.md
	@@ -1,482 +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"

	## :auth

	Authentication / authorization settings.

	* `auth_template`: authentication form template. By default it's `show.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/show.html.eex`.
	* `oauth_consumer_template`: OAuth consumer mode authentication form template. By default it's `consumer.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex`.
	* `oauth_consumer_strategies`: the list of enabled OAuth consumer strategies; by default it's set by OAUTH_CONSUMER_STRATEGIES environment variable.

	# OAuth consumer mode

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

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

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

	* 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/lib/mix/tasks/pleroma/user.ex b/lib/mix/tasks/pleroma/user.ex
	index 2b832f643..b396ff0de 100644
	--- a/lib/mix/tasks/pleroma/user.ex
	+++ b/lib/mix/tasks/pleroma/user.ex
	@@ -1,360 +1,429 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.User do
	use Mix.Task
	import Ecto.Changeset
	alias Mix.Tasks.Pleroma.Common
	alias Pleroma.User
	+ alias Pleroma.UserInviteToken

	@shortdoc "Manages Pleroma users"
	@moduledoc """
	Manages Pleroma users.

	## Create a new user.

	mix pleroma.user new NICKNAME EMAIL [OPTION...]

	Options:
	- `--name NAME` - the user's name (i.e., "Lain Iwakura")
	- `--bio BIO` - the user's bio
	- `--password PASSWORD` - the user's password
	- `--moderator`/`--no-moderator` - whether the user is a moderator
	- `--admin`/`--no-admin` - whether the user is an admin
	- `-y`, `--assume-yes`/`--no-assume-yes` - whether to assume yes to all questions

	## Generate an invite link.

	- mix pleroma.user invite
	+ mix pleroma.user invite [OPTION...]
	+
	+ Options:
	+ - `--expires_at DATE` - last day on which token is active (e.g. "2019-04-05")
	+ - `--max_use NUMBER` - maximum numbers of token uses
	+
	+ ## List generated invites
	+
	+ mix pleroma.user invites
	+
	+ ## Revoke invite
	+
	+ mix pleroma.user revoke_invite TOKEN OR TOKEN_ID

	## Delete the user's account.

	mix pleroma.user rm NICKNAME

	## Delete the user's activities.

	mix pleroma.user delete_activities NICKNAME

	## Deactivate or activate the user's account.

	mix pleroma.user toggle_activated NICKNAME

	## Unsubscribe local users from user's account and deactivate it

	mix pleroma.user unsubscribe NICKNAME

	## Create a password reset link.

	mix pleroma.user reset_password NICKNAME

	## Set the value of the given user's settings.

	mix pleroma.user set NICKNAME [OPTION...]

	Options:
	- `--locked`/`--no-locked` - whether the user's account is locked
	- `--moderator`/`--no-moderator` - whether the user is a moderator
	- `--admin`/`--no-admin` - whether the user is an admin

	## Add tags to a user.

	mix pleroma.user tag NICKNAME TAGS

	## Delete tags from a user.

	mix pleroma.user untag NICKNAME TAGS
	"""
	def run(["new", nickname, email \| rest]) do
	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	name: :string,
	bio: :string,
	password: :string,
	moderator: :boolean,
	admin: :boolean,
	assume_yes: :boolean
	],
	aliases: [
	y: :assume_yes
	]
	)

	name = Keyword.get(options, :name, nickname)
	bio = Keyword.get(options, :bio, "")

	{password, generated_password?} =
	case Keyword.get(options, :password) do
	nil ->
	{:crypto.strong_rand_bytes(16) \|> Base.encode64(), true}

	password ->
	{password, false}
	end

	moderator? = Keyword.get(options, :moderator, false)
	admin? = Keyword.get(options, :admin, false)
	assume_yes? = Keyword.get(options, :assume_yes, false)

	Mix.shell().info("""
	A user will be created with the following information:
	- nickname: #{nickname}
	- email: #{email}
	- password: #{
	if(generated_password?, do: "[generated; a reset link will be created]", else: password)
	}
	- name: #{name}
	- bio: #{bio}
	- moderator: #{if(moderator?, do: "true", else: "false")}
	- admin: #{if(admin?, do: "true", else: "false")}
	""")

	proceed? = assume_yes? or Mix.shell().yes?("Continue?")

	unless not proceed? do
	Common.start_pleroma()

	params = %{
	nickname: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	name: name,
	bio: bio
	}

	changeset = User.register_changeset(%User{}, params, confirmed: true)
	{:ok, _user} = User.register(changeset)

	Mix.shell().info("User #{nickname} created")

	if moderator? do
	run(["set", nickname, "--moderator"])
	end

	if admin? do
	run(["set", nickname, "--admin"])
	end

	if generated_password? do
	run(["reset_password", nickname])
	end
	else
	Mix.shell().info("User will not be created.")
	end
	end

	def run(["rm", nickname]) do
	Common.start_pleroma()

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	User.delete(user)
	Mix.shell().info("User #{nickname} deleted.")
	else
	_ ->
	Mix.shell().error("No local user #{nickname}")
	end
	end

	def run(["toggle_activated", nickname]) do
	Common.start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	{:ok, user} = User.deactivate(user, !user.info.deactivated)

	Mix.shell().info(
	"Activation status of #{nickname}: #{if(user.info.deactivated, do: "de", else: "")}activated"
	)
	else
	_ ->
	Mix.shell().error("No user #{nickname}")
	end
	end

	def run(["reset_password", nickname]) do
	Common.start_pleroma()

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
	{:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
	Mix.shell().info("Generated password reset token for #{user.nickname}")

	IO.puts(
	"URL: #{
	Pleroma.Web.Router.Helpers.util_url(
	Pleroma.Web.Endpoint,
	:show_password_reset,
	token.token
	)
	}"
	)
	else
	_ ->
	Mix.shell().error("No local user #{nickname}")
	end
	end

	def run(["unsubscribe", nickname]) do
	Common.start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	Mix.shell().info("Deactivating #{user.nickname}")
	User.deactivate(user)

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

	Enum.each(friends, fn friend ->
	user = User.get_cached_by_id(user.id)

	Mix.shell().info("Unsubscribing #{friend.nickname} from #{user.nickname}")
	User.unfollow(user, friend)
	end)

	:timer.sleep(500)

	user = User.get_cached_by_id(user.id)

	if Enum.empty?(user.following) do
	Mix.shell().info("Successfully unsubscribed all followers from #{user.nickname}")
	end
	else
	_ ->
	Mix.shell().error("No user #{nickname}")
	end
	end

	def run(["set", nickname \| rest]) do
	Common.start_pleroma()

	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	moderator: :boolean,
	admin: :boolean,
	locked: :boolean
	]
	)

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	user =
	case Keyword.get(options, :moderator) do
	nil -> user
	value -> set_moderator(user, value)
	end

	user =
	case Keyword.get(options, :locked) do
	nil -> user
	value -> set_locked(user, value)
	end

	_user =
	case Keyword.get(options, :admin) do
	nil -> user
	value -> set_admin(user, value)
	end
	else
	_ ->
	Mix.shell().error("No local user #{nickname}")
	end
	end

	def run(["tag", nickname \| tags]) do
	Common.start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	user = user \|> User.tag(tags)

	Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}")
	else
	_ ->
	Mix.shell().error("Could not change user tags for #{nickname}")
	end
	end

	def run(["untag", nickname \| tags]) do
	Common.start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	user = user \|> User.untag(tags)

	Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}")
	else
	_ ->
	Mix.shell().error("Could not change user tags for #{nickname}")
	end
	end

	- def run(["invite"]) do
	+ def run(["invite" \| rest]) do
	+ {options, [], []} =
	+ OptionParser.parse(rest,
	+ strict: [
	+ expires_at: :string,
	+ max_use: :integer
	+ ]
	+ )
	+
	+ options =
	+ options
	+ \|> Keyword.update(:expires_at, {:ok, nil}, fn
	+ nil -> {:ok, nil}
	+ val -> Date.from_iso8601(val)
	+ end)
	+ \|> Enum.into(%{})
	+
	Common.start_pleroma()

	- with {:ok, token} <- Pleroma.UserInviteToken.create_token() do
	- Mix.shell().info("Generated user invite token")
	+ with {:ok, val} <- options[:expires_at],
	+ options = Map.put(options, :expires_at, val),
	+ {:ok, invite} <- UserInviteToken.create_invite(options) do
	+ Mix.shell().info(
	+ "Generated user invite token " <> String.replace(invite.invite_type, "_", " ")
	+ )

	url =
	Pleroma.Web.Router.Helpers.redirect_url(
	Pleroma.Web.Endpoint,
	:registration_page,
	- token.token
	+ invite.token
	)

	IO.puts(url)
	else
	- _ ->
	- Mix.shell().error("Could not create invite token.")
	+ error ->
	+ Mix.shell().error("Could not create invite token: #{inspect(error)}")
	+ end
	+ end
	+
	+ def run(["invites"]) do
	+ Common.start_pleroma()
	+
	+ Mix.shell().info("Invites list:")
	+
	+ UserInviteToken.list_invites()
	+ \|> Enum.each(fn invite ->
	+ expire_info =
	+ with expires_at when not is_nil(expires_at) <- invite.expires_at do
	+ " \| Expires at: #{Date.to_string(expires_at)}"
	+ end
	+
	+ using_info =
	+ with max_use when not is_nil(max_use) <- invite.max_use do
	+ " \| Max use: #{max_use} Left use: #{max_use - invite.uses}"
	+ end
	+
	+ Mix.shell().info(
	+ "ID: #{invite.id} \| Token: #{invite.token} \| Token type: #{invite.invite_type} \| Used: #{
	+ invite.used
	+ }#{expire_info}#{using_info}"
	+ )
	+ end)
	+ end
	+
	+ def run(["revoke_invite", token]) do
	+ Common.start_pleroma()
	+
	+ with {:ok, invite} <- UserInviteToken.find_by_token(token),
	+ {:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
	+ Mix.shell().info("Invite for token #{token} was revoked.")
	+ else
	+ _ -> Mix.shell().error("No invite found with token #{token}")
	end
	end

	def run(["delete_activities", nickname]) do
	Common.start_pleroma()

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	User.delete_user_activities(user)
	Mix.shell().info("User #{nickname} statuses deleted.")
	else
	_ ->
	Mix.shell().error("No local user #{nickname}")
	end
	end

	defp set_moderator(user, value) do
	info_cng = User.Info.admin_api_update(user.info, %{is_moderator: value})

	user_cng =
	Ecto.Changeset.change(user)
	\|> put_embed(:info, info_cng)

	{:ok, user} = User.update_and_set_cache(user_cng)

	Mix.shell().info("Moderator status of #{user.nickname}: #{user.info.is_moderator}")
	user
	end

	defp set_admin(user, value) do
	info_cng = User.Info.admin_api_update(user.info, %{is_admin: value})

	user_cng =
	Ecto.Changeset.change(user)
	\|> put_embed(:info, info_cng)

	{:ok, user} = User.update_and_set_cache(user_cng)

	Mix.shell().info("Admin status of #{user.nickname}: #{user.info.is_admin}")
	user
	end

	defp set_locked(user, value) do
	info_cng = User.Info.user_upgrade(user.info, %{locked: value})

	user_cng =
	Ecto.Changeset.change(user)
	\|> put_embed(:info, info_cng)

	{:ok, user} = User.update_and_set_cache(user_cng)

	Mix.shell().info("Locked status of #{user.nickname}: #{user.info.locked}")
	user
	end
	end
	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/notification.ex b/lib/pleroma/notification.ex
	index cac10f24a..15789907a 100644
	--- a/lib/pleroma/notification.ex
	+++ b/lib/pleroma/notification.ex
	@@ -1,157 +1,207 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Notification do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils

	import Ecto.Query
	import Ecto.Changeset

	schema "notifications" do
	field(:seen, :boolean, default: false)
	belongs_to(:user, User, type: Pleroma.FlakeId)
	belongs_to(:activity, Activity, type: Pleroma.FlakeId)

	timestamps()
	end

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

	def for_user_query(user) do
	Notification
	\|> where(user_id: ^user.id)
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> join(:left, [n, a], object in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE((? -> 'object'::text) ->> 'id'::text)",
	object.data,
	a.data
	)
	)
	\|> preload([n, a, o], activity: {a, object: o})
	end

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

	def set_read_up_to(%{id: user_id} = _user, id) do
	query =
	from(
	n in Notification,
	where: n.user_id == ^user_id,
	where: n.id <= ^id,
	update: [
	set: [seen: true]
	]
	)

	Repo.update_all(query, [])
	end

	def read_one(%User{} = user, notification_id) do
	with {:ok, %Notification{} = notification} <- get(user, notification_id) do
	notification
	\|> changeset(%{seen: true})
	\|> Repo.update()
	end
	end

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

	notification = Repo.one(query)

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

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

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

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

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

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

	def create_notifications(%Activity{data: %{"to" => _, "type" => type}} = activity)
	when type in ["Create", "Like", "Announce", "Follow"] do
	users = get_notified_from_activity(activity)

	notifications = Enum.map(users, fn user -> create_notification(activity, user) end)
	{:ok, notifications}
	end

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

	# TODO move to sql, too.
	def create_notification(%Activity{} = activity, %User{} = user) do
	- unless User.blocks?(user, %{ap_id: activity.data["actor"]}) or
	- CommonAPI.thread_muted?(user, activity) or user.ap_id == activity.data["actor"] or
	- (activity.data["type"] == "Follow" and
	- Enum.any?(Notification.for_user(user), fn notif ->
	- notif.activity.data["type"] == "Follow" and
	- notif.activity.data["actor"] == activity.data["actor"]
	- end)) do
	+ unless skip?(activity, user) do
	notification = %Notification{user_id: user.id, activity: activity}
	{:ok, notification} = Repo.insert(notification)
	Pleroma.Web.Streamer.stream("user", notification)
	Pleroma.Web.Push.send(notification)
	notification
	end
	end

	def get_notified_from_activity(activity, local_only \\ true)

	def get_notified_from_activity(
	%Activity{data: %{"to" => _, "type" => type} = _data} = activity,
	local_only
	)
	when type in ["Create", "Like", "Announce", "Follow"] do
	recipients =
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	+ \|> Utils.maybe_notify_subscribers(activity)
	\|> Enum.uniq()

	User.get_users_from_set(recipients, local_only)
	end

	def get_notified_from_activity(_, _local_only), do: []
	+
	+ def skip?(activity, user) do
	+ [:self, :blocked, :local, :muted, :followers, :follows, :recently_followed]
	+ \|> Enum.any?(&skip?(&1, activity, user))
	+ end
	+
	+ def skip?(:self, activity, user) do
	+ activity.data["actor"] == user.ap_id
	+ end
	+
	+ def skip?(:blocked, activity, user) do
	+ actor = activity.data["actor"]
	+ User.blocks?(user, %{ap_id: actor})
	+ end
	+
	+ def skip?(:local, %{local: true}, %{info: %{notification_settings: %{"local" => false}}}),
	+ do: true
	+
	+ def skip?(:local, %{local: false}, %{info: %{notification_settings: %{"remote" => false}}}),
	+ do: true
	+
	+ def skip?(:muted, activity, user) do
	+ actor = activity.data["actor"]
	+
	+ User.mutes?(user, %{ap_id: actor}) or
	+ CommonAPI.thread_muted?(user, activity)
	+ end
	+
	+ def skip?(
	+ :followers,
	+ activity,
	+ %{info: %{notification_settings: %{"followers" => false}}} = user
	+ ) do
	+ actor = activity.data["actor"]
	+ follower = User.get_cached_by_ap_id(actor)
	+ User.following?(follower, user)
	+ end
	+
	+ def skip?(:follows, activity, %{info: %{notification_settings: %{"follows" => false}}} = user) do
	+ actor = activity.data["actor"]
	+ followed = User.get_by_ap_id(actor)
	+ User.following?(user, followed)
	+ end
	+
	+ def skip?(:recently_followed, %{data: %{"type" => "Follow"}} = activity, user) do
	+ actor = activity.data["actor"]
	+
	+ Notification.for_user(user)
	+ \|> Enum.any?(fn
	+ %{activity: %{data: %{"type" => "Follow", "actor" => ^actor}}} -> true
	+ _ -> false
	+ end)
	+ end
	+
	+ def skip?(_, _, _), do: false
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 37772d7a1..ab9cb5b1b 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1389 +1,1448 @@
	# 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.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)
	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([: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_cached_by_nickname(nickname)
	end

	def set_cache({:ok, user}), do: set_cache(user)
	def set_cache({:error, err}), do: {:error, err}

	def set_cache(%User{} = user) do
	Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user))
	{:ok, user}
	end

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

	def invalidate_cache(user) do
	Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	Cachex.del(:user_cache, "nickname:#{user.nickname}")
	Cachex.del(:user_cache, "user_info:#{user.id}")
	end

	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"
	Cachex.fetch!(:user_cache, key, fn _ -> get_by_ap_id(ap_id) end)
	end

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

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

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

	get_cached_by_ap_id(ap_id)
	end

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

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

	def get_by_email(email), do: Repo.get_by(User, email: email)

	def get_by_nickname_or_email(nickname_or_email) do
	get_by_nickname(nickname_or_email) \|\| get_by_email(nickname_or_email)
	end

	def get_cached_user_info(user) do
	key = "user_info:#{user.id}"
	Cachex.fetch!(:user_cache, key, fn _ -> user_info(user) end)
	end

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

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

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	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
	# TODO turn into job
	{: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 subscribe(subscriber, %{ap_id: ap_id}) do
	+ deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
	+
	+ with %User{} = subscribed <- get_cached_by_ap_id(ap_id) do
	+ blocked = blocks?(subscribed, subscriber) and deny_follow_blocked
	+
	+ if blocked do
	+ {:error, "Could not subscribe: #{subscribed.nickname} is blocking you"}
	+ else
	+ info_cng =
	+ subscribed.info
	+ \|> User.Info.add_to_subscribers(subscriber.ap_id)
	+
	+ change(subscribed)
	+ \|> put_embed(:info, info_cng)
	+ \|> update_and_set_cache()
	+ end
	+ end
	+ end
	+
	+ def unsubscribe(unsubscriber, %{ap_id: ap_id}) do
	+ with %User{} = user <- get_cached_by_ap_id(ap_id) do
	+ info_cng =
	+ user.info
	+ \|> User.Info.remove_from_subscribers(unsubscriber.ap_id)
	+
	+ change(user)
	+ \|> put_embed(:info, info_cng)
	+ \|> update_and_set_cache()
	+ end
	+ end
	+
	def block(blocker, %User{ap_id: ap_id} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

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

	+ {:ok, blocker} = update_follower_count(blocker)
	+
	info_cng =
	blocker.info
	\|> User.Info.add_to_block(ap_id)

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

	update_and_set_cache(cng)
	end

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

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

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

	update_and_set_cache(cng)
	end

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

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

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

	+ def subscribed_to?(user, %{ap_id: ap_id}) do
	+ with %User{} = target <- User.get_by_ap_id(ap_id) do
	+ Enum.member?(target.info.subscribers, user.ap_id)
	+ 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 subscribers(user),
	+ do: Repo.all(from(u in User, where: u.ap_id in ^user.info.subscribers))
	+
	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 update_notification_settings(%User{} = user, settings \\ %{}) do
	+ info_changeset = User.Info.update_notification_settings(user.info, settings)
	+
	+ change(user)
	+ \|> put_embed(:info, info_changeset)
	+ \|> update_and_set_cache()
	+ end
	+
	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_cached_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_cached_by_ap_id(relay_uri) do
	user
	else
	changes =
	%User{info: %User.Info{}}
	\|> cast(%{}, [:ap_id, :nickname, :local])
	\|> put_change(:ap_id, relay_uri)
	\|> put_change(:nickname, nil)
	\|> put_change(:local, true)
	\|> put_change(:follower_address, relay_uri <> "/followers")

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

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

	{:ok, key}
	end

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

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

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

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

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

	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: 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_cached_by_id(a.id),
	%User{} = b <- User.get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	_e ->
	:error
	end
	end

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

	def parse_bio(bio, 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(get_by_nickname(nickname), tags)

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

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

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

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

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

	updated_user
	end

	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
	end
	diff --git a/lib/pleroma/user/info.ex b/lib/pleroma/user/info.ex
	index 740a46727..5afa7988c 100644
	--- a/lib/pleroma/user/info.ex
	+++ b/lib/pleroma/user/info.ex
	@@ -1,275 +1,309 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.Info do
	use Ecto.Schema
	import Ecto.Changeset

	alias Pleroma.User.Info

	embedded_schema do
	field(:banner, :map, default: %{})
	field(:background, :map, default: %{})
	field(:source_data, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	field(:locked, :boolean, default: false)
	field(:confirmation_pending, :boolean, default: false)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:blocks, {:array, :string}, default: [])
	field(:domain_blocks, {:array, :string}, default: [])
	field(:mutes, {:array, :string}, default: [])
	field(:muted_reblogs, {:array, :string}, default: [])
	+ field(:subscribers, {:array, :string}, default: [])
	field(:deactivated, :boolean, default: false)
	field(:no_rich_text, :boolean, default: false)
	field(:ap_enabled, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	field(:keys, :string, default: nil)
	field(:settings, :map, default: nil)
	field(:magic_key, :string, default: nil)
	field(:uri, :string, default: nil)
	field(:topic, :string, default: nil)
	field(:hub, :string, default: nil)
	field(:salmon, :string, default: nil)
	field(:hide_followers, :boolean, default: false)
	field(:hide_follows, :boolean, default: false)
	field(:pinned_activities, {:array, :string}, default: [])
	field(:flavour, :string, default: nil)

	+ field(:notification_settings, :map,
	+ default: %{"remote" => true, "local" => true, "followers" => true, "follows" => true}
	+ )
	+
	# Found in the wild
	# ap_id -> Where is this used?
	# bio -> Where is this used?
	# avatar -> Where is this used?
	# fqn -> Where is this used?
	# host -> Where is this used?
	# subject _> Where is this used?
	end

	def set_activation_status(info, deactivated) do
	params = %{deactivated: deactivated}

	info
	\|> cast(params, [:deactivated])
	\|> validate_required([:deactivated])
	end

	+ def update_notification_settings(info, settings) do
	+ notification_settings =
	+ info.notification_settings
	+ \|> Map.merge(settings)
	+ \|> Map.take(["remote", "local", "followers", "follows"])
	+
	+ params = %{notification_settings: notification_settings}
	+
	+ info
	+ \|> cast(params, [:notification_settings])
	+ \|> validate_required([:notification_settings])
	+ end
	+
	def add_to_note_count(info, number) do
	set_note_count(info, info.note_count + number)
	end

	def set_note_count(info, number) do
	params = %{note_count: Enum.max([0, number])}

	info
	\|> cast(params, [:note_count])
	\|> validate_required([:note_count])
	end

	def set_follower_count(info, number) do
	params = %{follower_count: Enum.max([0, number])}

	info
	\|> cast(params, [:follower_count])
	\|> validate_required([:follower_count])
	end

	def set_mutes(info, mutes) do
	params = %{mutes: mutes}

	info
	\|> cast(params, [:mutes])
	\|> validate_required([:mutes])
	end

	def set_blocks(info, blocks) do
	params = %{blocks: blocks}

	info
	\|> cast(params, [:blocks])
	\|> validate_required([:blocks])
	end

	+ def set_subscribers(info, subscribers) do
	+ params = %{subscribers: subscribers}
	+
	+ info
	+ \|> cast(params, [:subscribers])
	+ \|> validate_required([:subscribers])
	+ end
	+
	def add_to_mutes(info, muted) do
	set_mutes(info, Enum.uniq([muted \| info.mutes]))
	end

	def remove_from_mutes(info, muted) do
	set_mutes(info, List.delete(info.mutes, muted))
	end

	def add_to_block(info, blocked) do
	set_blocks(info, Enum.uniq([blocked \| info.blocks]))
	end

	def remove_from_block(info, blocked) do
	set_blocks(info, List.delete(info.blocks, blocked))
	end

	+ def add_to_subscribers(info, subscribed) do
	+ set_subscribers(info, Enum.uniq([subscribed \| info.subscribers]))
	+ end
	+
	+ def remove_from_subscribers(info, subscribed) do
	+ set_subscribers(info, List.delete(info.subscribers, subscribed))
	+ end
	+
	def set_domain_blocks(info, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

	info
	\|> cast(params, [:domain_blocks])
	\|> validate_required([:domain_blocks])
	end

	def add_to_domain_block(info, domain_blocked) do
	set_domain_blocks(info, Enum.uniq([domain_blocked \| info.domain_blocks]))
	end

	def remove_from_domain_block(info, domain_blocked) do
	set_domain_blocks(info, List.delete(info.domain_blocks, domain_blocked))
	end

	def set_keys(info, keys) do
	params = %{keys: keys}

	info
	\|> cast(params, [:keys])
	\|> validate_required([:keys])
	end

	def remote_user_creation(info, params) do
	info
	\|> cast(params, [
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key,
	:uri,
	:hub,
	:topic,
	:salmon
	])
	end

	def user_upgrade(info, params) do
	info
	\|> cast(params, [
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key
	])
	end

	def profile_update(info, params) do
	info
	\|> cast(params, [
	:locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:background,
	:show_role
	])
	end

	def confirmation_changeset(info, :confirmed) do
	confirmation_changeset(info, %{
	confirmation_pending: false,
	confirmation_token: nil
	})
	end

	def confirmation_changeset(info, :unconfirmed) do
	confirmation_changeset(info, %{
	confirmation_pending: true,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	})
	end

	def confirmation_changeset(info, params) do
	cast(info, params, [:confirmation_pending, :confirmation_token])
	end

	def mastodon_profile_update(info, params) do
	info
	\|> cast(params, [
	:locked,
	:banner
	])
	end

	def mastodon_settings_update(info, settings) do
	params = %{settings: settings}

	info
	\|> cast(params, [:settings])
	\|> validate_required([:settings])
	end

	def mastodon_flavour_update(info, flavour) do
	params = %{flavour: flavour}

	info
	\|> cast(params, [:flavour])
	\|> validate_required([:flavour])
	end

	def set_source_data(info, source_data) do
	params = %{source_data: source_data}

	info
	\|> cast(params, [:source_data])
	\|> validate_required([:source_data])
	end

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

	def add_pinnned_activity(info, %Pleroma.Activity{id: id}) do
	if id not in info.pinned_activities do
	max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
	params = %{pinned_activities: info.pinned_activities ++ [id]}

	info
	\|> cast(params, [:pinned_activities])
	\|> validate_length(:pinned_activities,
	max: max_pinned_statuses,
	message: "You have already pinned the maximum number of statuses"
	)
	else
	change(info)
	end
	end

	def remove_pinnned_activity(info, %Pleroma.Activity{id: id}) do
	params = %{pinned_activities: List.delete(info.pinned_activities, id)}

	cast(info, params, [:pinned_activities])
	end

	def roles(%Info{is_moderator: is_moderator, is_admin: is_admin}) do
	%{
	admin: is_admin,
	moderator: is_moderator
	}
	end

	def add_reblog_mute(info, ap_id) do
	params = %{muted_reblogs: info.muted_reblogs ++ [ap_id]}

	cast(info, params, [:muted_reblogs])
	end

	def remove_reblog_mute(info, ap_id) do
	params = %{muted_reblogs: List.delete(info.muted_reblogs, ap_id)}

	cast(info, params, [:muted_reblogs])
	end
	end
	diff --git a/lib/pleroma/user_invite_token.ex b/lib/pleroma/user_invite_token.ex
	index 9c5579934..86f0a5486 100644
	--- a/lib/pleroma/user_invite_token.ex
	+++ b/lib/pleroma/user_invite_token.ex
	@@ -1,45 +1,124 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserInviteToken do
	use Ecto.Schema

	import Ecto.Changeset
	-
	+ import Ecto.Query
	alias Pleroma.Repo
	alias Pleroma.UserInviteToken

	+ @type t :: %__MODULE__{}
	+ @type token :: String.t()
	+
	schema "user_invite_tokens" do
	field(:token, :string)
	field(:used, :boolean, default: false)
	+ field(:max_use, :integer)
	+ field(:expires_at, :date)
	+ field(:uses, :integer, default: 0)
	+ field(:invite_type, :string)

	timestamps()
	end

	- def create_token do
	+ @spec create_invite(map()) :: UserInviteToken.t()
	+ def create_invite(params \\ %{}) do
	+ %UserInviteToken{}
	+ \|> cast(params, [:max_use, :expires_at])
	+ \|> add_token()
	+ \|> assign_type()
	+ \|> Repo.insert()
	+ end
	+
	+ defp add_token(changeset) do
	token = :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	+ put_change(changeset, :token, token)
	+ end

	- token = %UserInviteToken{
	- used: false,
	- token: token
	- }
	+ defp assign_type(%{changes: %{max_use: _max_use, expires_at: _expires_at}} = changeset) do
	+ put_change(changeset, :invite_type, "reusable_date_limited")
	+ end
	+
	+ defp assign_type(%{changes: %{expires_at: _expires_at}} = changeset) do
	+ put_change(changeset, :invite_type, "date_limited")
	+ end
	+
	+ defp assign_type(%{changes: %{max_use: _max_use}} = changeset) do
	+ put_change(changeset, :invite_type, "reusable")
	+ end
	+
	+ defp assign_type(changeset), do: put_change(changeset, :invite_type, "one_time")

	- Repo.insert(token)
	+ @spec list_invites() :: [UserInviteToken.t()]
	+ def list_invites do
	+ query = from(u in UserInviteToken, order_by: u.id)
	+ Repo.all(query)
	end

	- def used_changeset(struct) do
	- struct
	- \|> cast(%{}, [])
	- \|> put_change(:used, true)
	+ @spec update_invite!(UserInviteToken.t(), map()) :: UserInviteToken.t() \| no_return()
	+ def update_invite!(invite, changes) do
	+ change(invite, changes) \|> Repo.update!()
	end

	- def mark_as_used(token) do
	- with %{used: false} = token <- Repo.get_by(UserInviteToken, %{token: token}),
	- {:ok, token} <- Repo.update(used_changeset(token)) do
	- {:ok, token}
	- else
	- _e -> {:error, token}
	+ @spec update_invite(UserInviteToken.t(), map()) ::
	+ {:ok, UserInviteToken.t()} \| {:error, Changeset.t()}
	+ def update_invite(invite, changes) do
	+ change(invite, changes) \|> Repo.update()
	+ end
	+
	+ @spec find_by_token!(token()) :: UserInviteToken.t() \| no_return()
	+ def find_by_token!(token), do: Repo.get_by!(UserInviteToken, token: token)
	+
	+ @spec find_by_token(token()) :: {:ok, UserInviteToken.t()} \| nil
	+ def find_by_token(token) do
	+ with invite <- Repo.get_by(UserInviteToken, token: token) do
	+ {:ok, invite}
	end
	end
	+
	+ @spec valid_invite?(UserInviteToken.t()) :: boolean()
	+ def valid_invite?(%{invite_type: "one_time"} = invite) do
	+ not invite.used
	+ end
	+
	+ def valid_invite?(%{invite_type: "date_limited"} = invite) do
	+ not_overdue_date?(invite) and not invite.used
	+ end
	+
	+ def valid_invite?(%{invite_type: "reusable"} = invite) do
	+ invite.uses < invite.max_use and not invite.used
	+ end
	+
	+ def valid_invite?(%{invite_type: "reusable_date_limited"} = invite) do
	+ not_overdue_date?(invite) and invite.uses < invite.max_use and not invite.used
	+ end
	+
	+ defp not_overdue_date?(%{expires_at: expires_at}) do
	+ Date.compare(Date.utc_today(), expires_at) in [:lt, :eq]
	+ end
	+
	+ @spec update_usage!(UserInviteToken.t()) :: nil \| UserInviteToken.t() \| no_return()
	+ def update_usage!(%{invite_type: "date_limited"}), do: nil
	+
	+ def update_usage!(%{invite_type: "one_time"} = invite),
	+ do: update_invite!(invite, %{used: true})
	+
	+ def update_usage!(%{invite_type: invite_type} = invite)
	+ when invite_type == "reusable" or invite_type == "reusable_date_limited" do
	+ changes = %{
	+ uses: invite.uses + 1
	+ }
	+
	+ changes =
	+ if changes.uses >= invite.max_use do
	+ Map.put(changes, :used, true)
	+ else
	+ changes
	+ end
	+
	+ update_invite!(invite, changes)
	+ end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index 25726ad25..4dc2e08df 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1043 +1,1059 @@
	# 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
	+ \|> fix_summary
	+ end
	+
	+ def fix_summary(%{"summary" => nil} = object) do
	+ object
	+ \|> Map.put("summary", "")
	+ end
	+
	+ def fix_summary(%{"summary" => _} = object) do
	+ # summary is present, nothing to do
	+ object
	+ end
	+
	+ def fix_summary(object) do
	+ object
	+ \|> Map.put("summary", "")
	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_cached_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

	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) do
	with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
	{: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/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/admin_api_controller.ex
	index c6a6b3a6d..920a9c211 100644
	--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
	+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
	@@ -1,302 +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.AdminAPI.AdminAPIController do
	use Pleroma.Web, :controller
	alias Pleroma.User
	+ alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.AdminAPI.Search

	import Pleroma.Web.ControllerHelper, only: [json_response: 3]

	require Logger

	@users_page_size 50

	action_fallback(:errors)

	def user_delete(conn, %{"nickname" => nickname}) do
	User.get_cached_by_nickname(nickname)
	\|> User.delete()

	conn
	\|> json(nickname)
	end

	def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.follow(follower, followed)
	end

	conn
	\|> json("ok")
	end

	def user_unfollow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.unfollow(follower, followed)
	end

	conn
	\|> json("ok")
	end

	def user_create(
	conn,
	%{"nickname" => nickname, "email" => email, "password" => password}
	) do
	user_data = %{
	nickname: nickname,
	name: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	bio: "."
	}

	changeset = User.register_changeset(%User{}, user_data, confirmed: true)
	{:ok, user} = User.register(changeset)

	conn
	\|> json(user.nickname)
	end

	def user_show(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> json(AccountView.render("show.json", %{user: user}))
	else
	_ -> {:error, :not_found}
	end
	end

	def user_toggle_activation(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)

	{:ok, updated_user} = User.deactivate(user, !user.info.deactivated)

	conn
	\|> json(AccountView.render("show.json", %{user: updated_user}))
	end

	def tag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.tag(nicknames, tags),
	do: json_response(conn, :no_content, "")
	end

	def untag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.untag(nicknames, tags),
	do: json_response(conn, :no_content, "")
	end

	def list_users(conn, params) do
	{page, page_size} = page_params(params)
	filters = maybe_parse_filters(params["filters"])

	search_params = %{
	query: params["query"],
	page: page,
	page_size: page_size
	}

	with {:ok, users, count} <- Search.user(Map.merge(search_params, filters)),
	do:
	conn
	\|> json(
	AccountView.render("index.json",
	users: users,
	count: count,
	page_size: page_size
	)
	)
	end

	@filters ~w(local external active deactivated)

	defp maybe_parse_filters(filters) when is_nil(filters) or filters == "", do: %{}

	@spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} \| %{}
	defp maybe_parse_filters(filters) do
	filters
	\|> String.split(",")
	\|> Enum.filter(&Enum.member?(@filters, &1))
	\|> Enum.map(&String.to_atom(&1))
	\|> Enum.into(%{}, &{&1, true})
	end

	def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname})
	when permission_group in ["moderator", "admin"] do
	user = User.get_cached_by_nickname(nickname)

	info =
	%{}
	\|> Map.put("is_" <> permission_group, true)

	info_cng = User.Info.admin_api_update(user.info, info)

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

	{:ok, _user} = User.update_and_set_cache(cng)

	json(conn, info)
	end

	def right_add(conn, _) do
	conn
	\|> put_status(404)
	\|> json(%{error: "No such permission_group"})
	end

	def right_get(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)

	conn
	\|> json(%{
	is_moderator: user.info.is_moderator,
	is_admin: user.info.is_admin
	})
	end

	def right_delete(
	%{assigns: %{user: %User{:nickname => admin_nickname}}} = conn,
	%{
	"permission_group" => permission_group,
	"nickname" => nickname
	}
	)
	when permission_group in ["moderator", "admin"] do
	if admin_nickname == nickname do
	conn
	\|> put_status(403)
	\|> json(%{error: "You can't revoke your own admin status."})
	else
	user = User.get_cached_by_nickname(nickname)

	info =
	%{}
	\|> Map.put("is_" <> permission_group, false)

	info_cng = User.Info.admin_api_update(user.info, info)

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

	{:ok, _user} = User.update_and_set_cache(cng)

	json(conn, info)
	end
	end

	def right_delete(conn, _) do
	conn
	\|> put_status(404)
	\|> json(%{error: "No such permission_group"})
	end

	def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do
	with {:ok, status} <- Ecto.Type.cast(:boolean, status),
	%User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, _} <- User.deactivate(user, !status),
	do: json_response(conn, :no_content, "")
	end

	def relay_follow(conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.follow(target) do
	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	def relay_unfollow(conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.unfollow(target) do
	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	@doc "Sends registration invite via email"
	def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
	with true <-
	Pleroma.Config.get([:instance, :invites_enabled]) &&
	!Pleroma.Config.get([:instance, :registrations_open]),
	- {:ok, invite_token} <- Pleroma.UserInviteToken.create_token(),
	+ {:ok, invite_token} <- UserInviteToken.create_invite(),
	email <-
	Pleroma.UserEmail.user_invitation_email(user, invite_token, email, params["name"]),
	{:ok, _} <- Pleroma.Mailer.deliver(email) do
	json_response(conn, :no_content, "")
	end
	end

	@doc "Get a account registeration invite token (base64 string)"
	- def get_invite_token(conn, _params) do
	- {:ok, token} = Pleroma.UserInviteToken.create_token()
	+ def get_invite_token(conn, params) do
	+ options = params["invite"] \|\| %{}
	+ {:ok, invite} = UserInviteToken.create_invite(options)

	conn
	- \|> json(token.token)
	+ \|> json(invite.token)
	+ end
	+
	+ @doc "Get list of created invites"
	+ def invites(conn, _params) do
	+ invites = UserInviteToken.list_invites()
	+
	+ conn
	+ \|> json(AccountView.render("invites.json", %{invites: invites}))
	+ end
	+
	+ @doc "Revokes invite by token"
	+ def revoke_invite(conn, %{"token" => token}) do
	+ invite = UserInviteToken.find_by_token!(token)
	+ {:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true})
	+
	+ conn
	+ \|> json(AccountView.render("invite.json", %{invite: updated_invite}))
	end

	@doc "Get a password reset token (base64 string) for given nickname"
	def get_password_reset(conn, %{"nickname" => nickname}) do
	(%User{local: true} = user) = User.get_cached_by_nickname(nickname)
	{:ok, token} = Pleroma.PasswordResetToken.create_token(user)

	conn
	\|> json(token.token)
	end

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

	def errors(conn, {:param_cast, _}) do
	conn
	\|> put_status(400)
	\|> json("Invalid parameters")
	end

	def errors(conn, _) do
	conn
	\|> put_status(500)
	\|> json("Something went wrong")
	end

	defp page_params(params) do
	{get_page(params["page"]), get_page_size(params["page_size"])}
	end

	defp get_page(page_string) when is_nil(page_string), do: 1

	defp get_page(page_string) do
	case Integer.parse(page_string) do
	{page, _} -> page
	:error -> 1
	end
	end

	defp get_page_size(page_size_string) when is_nil(page_size_string), do: @users_page_size

	defp get_page_size(page_size_string) do
	case Integer.parse(page_size_string) do
	{page_size, _} -> page_size
	:error -> @users_page_size
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/views/account_view.ex b/lib/pleroma/web/admin_api/views/account_view.ex
	index 4d6f921ef..28bb667d8 100644
	--- a/lib/pleroma/web/admin_api/views/account_view.ex
	+++ b/lib/pleroma/web/admin_api/views/account_view.ex
	@@ -1,29 +1,47 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AccountView do
	use Pleroma.Web, :view

	alias Pleroma.User.Info
	alias Pleroma.Web.AdminAPI.AccountView

	def render("index.json", %{users: users, count: count, page_size: page_size}) do
	%{
	users: render_many(users, AccountView, "show.json", as: :user),
	count: count,
	page_size: page_size
	}
	end

	def render("show.json", %{user: user}) do
	%{
	"id" => user.id,
	"nickname" => user.nickname,
	"deactivated" => user.info.deactivated,
	"local" => user.local,
	"roles" => Info.roles(user.info),
	"tags" => user.tags \|\| []
	}
	end
	+
	+ def render("invite.json", %{invite: invite}) do
	+ %{
	+ "id" => invite.id,
	+ "token" => invite.token,
	+ "used" => invite.used,
	+ "expires_at" => invite.expires_at,
	+ "uses" => invite.uses,
	+ "max_use" => invite.max_use,
	+ "invite_type" => invite.invite_type
	+ }
	+ end
	+
	+ def render("invites.json", %{invites: invites}) do
	+ %{
	+ invites: render_many(invites, AccountView, "invite.json", as: :invite)
	+ }
	+ end
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index 996fec500..435ce9f60 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,393 +1,412 @@
	# 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.ActivityPub.Visibility
	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_cached_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, _} ->
	%{
	"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_notify_subscribers(
	+ recipients,
	+ %Activity{data: %{"actor" => actor, "type" => type}} = activity
	+ )
	+ when type == "Create" do
	+ with %User{} = user <- User.get_cached_by_ap_id(actor) do
	+ subscriber_ids =
	+ user
	+ \|> User.subscribers()
	+ \|> Enum.filter(&Visibility.visible_for_user?(activity, &1))
	+ \|> Enum.map(& &1.ap_id)
	+
	+ recipients ++ subscriber_ids
	+ end
	+ end
	+
	+ def maybe_notify_subscribers(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/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index 965e50695..a1afa83eb 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,1609 +1,1637 @@
	# 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, tags} ->
	url = to_string(URI.merge(Web.base_url(), relative_url))

	%{
	"shortcode" => shortcode,
	"static_url" => url,
	"visible_in_picker" => true,
	"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_cached_by_id(params["id"]) do
	activities = ActivityPub.fetch_user_activities(user, reading_user, params)

	conn
	\|> add_link_headers(:user_statuses, activities, params["id"])
	\|> put_view(StatusView)
	\|> render("index.json", %{
	activities: activities,
	for: reading_user,
	as: :activity
	})
	end
	end

	def dm_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("blocking_user", user)
	\|> Map.put("user", user)
	\|> Map.put(:visibility, "direct")

	activities =
	[user.ap_id]
	\|> ActivityPub.fetch_activities_query(params)
	\|> 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_cached_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_cached_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_cached_by_id(id),
	followers <- MastodonAPI.get_followers(user, params) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_followers -> []
	true -> followers
	end

	conn
	\|> add_link_headers(:followers, followers, user)
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: followers, as: :user})
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
	with %User{} = user <- User.get_cached_by_id(id),
	followers <- MastodonAPI.get_friends(user, params) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_follows -> []
	true -> followers
	end

	conn
	\|> add_link_headers(:following, followers, user)
	\|> put_view(AccountView)
	\|> render("accounts.json", %{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_cached_by_id(id),
	{:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: followed, target: follower})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
	with %User{} = follower <- User.get_cached_by_id(id),
	{:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: followed, target: follower})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

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

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

	def mutes(%{assigns: %{user: user}} = conn, _) do
	with muted_accounts <- User.muted_users(user) do
	res = AccountView.render("accounts.json", users: muted_accounts, for: user, as: :user)
	json(conn, res)
	end
	end

	def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- User.get_cached_by_id(id),
	{:ok, blocker} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: blocker, target: blocked})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- User.get_cached_by_id(id),
	{:ok, blocker} <- User.unblock(blocker, blocked),
	{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: blocker, target: blocked})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def blocks(%{assigns: %{user: user}} = conn, _) do
	with blocked_accounts <- User.blocked_users(user) do
	res = AccountView.render("accounts.json", users: blocked_accounts, for: user, as: :user)
	json(conn, res)
	end
	end

	def domain_blocks(%{assigns: %{user: %{info: info}}} = conn, _) do
	json(conn, info.domain_blocks \|\| [])
	end

	def block_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
	User.block_domain(blocker, domain)
	json(conn, %{})
	end

	def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
	User.unblock_domain(blocker, domain)
	json(conn, %{})
	end

	+ def subscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	+ with %User{} = subscription_target <- User.get_cached_by_id(id),
	+ {:ok, subscription_target} = User.subscribe(user, subscription_target) do
	+ conn
	+ \|> put_view(AccountView)
	+ \|> render("relationship.json", %{user: user, target: subscription_target})
	+ else
	+ {:error, message} ->
	+ conn
	+ \|> put_resp_content_type("application/json")
	+ \|> send_resp(403, Jason.encode!(%{"error" => message}))
	+ end
	+ end
	+
	+ def unsubscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	+ with %User{} = subscription_target <- User.get_cached_by_id(id),
	+ {:ok, subscription_target} = User.unsubscribe(user, subscription_target) do
	+ conn
	+ \|> put_view(AccountView)
	+ \|> render("relationship.json", %{user: user, target: subscription_target})
	+ else
	+ {:error, message} ->
	+ conn
	+ \|> put_resp_content_type("application/json")
	+ \|> send_resp(403, Jason.encode!(%{"error" => message}))
	+ end
	+ end
	+
	def status_search(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_cached_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_cached_by_id(account_id) do
	Pleroma.List.follow(list, followed)
	end
	end)

	json(conn, %{})
	end

	def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
	accounts
	\|> Enum.each(fn account_id ->
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	%User{} = followed <- Pleroma.User.get_cached_by_id(account_id) do
	Pleroma.List.unfollow(list, followed)
	end
	end)

	json(conn, %{})
	end

	def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, users} = Pleroma.List.get_following(list) do
	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{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_cached_by_id(id) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: user, target: target})
	end
	end

	def empty_array(conn, _) do
	Logger.debug("Unimplemented, returning an empty array")
	json(conn, [])
	end

	def empty_object(conn, _) do
	Logger.debug("Unimplemented, returning an empty object")
	json(conn, %{})
	end

	def get_filters(%{assigns: %{user: user}} = conn, _) do
	filters = Filter.get_filters(user)
	res = FilterView.render("filters.json", filters: filters)
	json(conn, res)
	end

	def create_filter(
	%{assigns: %{user: user}} = conn,
	%{"phrase" => phrase, "context" => context} = params
	) do
	query = %Filter{
	user_id: user.id,
	phrase: phrase,
	context: context,
	hide: Map.get(params, "irreversible", 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/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
	index 7b43b1070..d87fdb15d 100644
	--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
	@@ -1,135 +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.MastodonAPI.AccountView do
	use Pleroma.Web, :view

	alias Pleroma.HTML
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MediaProxy

	def render("accounts.json", %{users: users} = opts) do
	users
	\|> render_many(AccountView, "account.json", opts)
	\|> Enum.filter(&Enum.any?/1)
	end

	def render("account.json", %{user: user} = opts) do
	if User.visible_for?(user, opts[:for]),
	do: do_render("account.json", opts),
	else: %{}
	end

	def render("mention.json", %{user: user}) do
	%{
	id: to_string(user.id),
	acct: user.nickname,
	username: username_from_nickname(user.nickname),
	url: user.ap_id
	}
	end

	def render("relationship.json", %{user: nil, target: _target}) do
	%{}
	end

	def render("relationship.json", %{user: %User{} = user, target: %User{} = target}) do
	follow_activity = Pleroma.Web.ActivityPub.Utils.fetch_latest_follow(user, target)

	requested =
	if follow_activity do
	follow_activity.data["state"] == "pending"
	else
	false
	end

	%{
	id: to_string(target.id),
	following: User.following?(user, target),
	followed_by: User.following?(target, user),
	blocking: User.blocks?(user, target),
	muting: User.mutes?(user, target),
	muting_notifications: false,
	+ subscribing: User.subscribed_to?(user, target),
	requested: requested,
	domain_blocking: false,
	showing_reblogs: User.showing_reblogs?(user, target),
	endorsed: false
	}
	end

	def render("relationships.json", %{user: user, targets: targets}) do
	render_many(targets, AccountView, "relationship.json", user: user, as: :target)
	end

	defp do_render("account.json", %{user: user} = opts) do
	image = User.avatar_url(user) \|> MediaProxy.url()
	header = User.banner_url(user) \|> MediaProxy.url()
	user_info = User.get_cached_user_info(user)
	bot = (user.info.source_data["type"] \|\| "Person") in ["Application", "Service"]

	emojis =
	(user.info.source_data["tag"] \|\| [])
	\|> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
	\|> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
	%{
	"shortcode" => String.trim(name, ":"),
	"url" => MediaProxy.url(url),
	"static_url" => MediaProxy.url(url),
	"visible_in_picker" => false
	}
	end)

	fields =
	(user.info.source_data["attachment"] \|\| [])
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)

	bio = HTML.filter_tags(user.bio, User.html_filter_policy(opts[:for]))

	relationship = render("relationship.json", %{user: opts[:for], target: user})

	%{
	id: to_string(user.id),
	username: username_from_nickname(user.nickname),
	acct: user.nickname,
	display_name: user.name \|\| user.nickname,
	locked: user_info.locked,
	created_at: Utils.to_masto_date(user.inserted_at),
	followers_count: user_info.follower_count,
	following_count: user_info.following_count,
	statuses_count: user_info.note_count,
	note: bio \|\| "",
	url: user.ap_id,
	avatar: image,
	avatar_static: image,
	header: header,
	header_static: header,
	emojis: emojis,
	fields: fields,
	bot: bot,
	source: %{
	note: "",
	privacy: user_info.default_scope,
	sensitive: false
	},

	# Pleroma extension
	- pleroma: %{
	- confirmation_pending: user_info.confirmation_pending,
	- tags: user.tags,
	- is_moderator: user.info.is_moderator,
	- is_admin: user.info.is_admin,
	- relationship: relationship
	- }
	+ pleroma:
	+ %{
	+ confirmation_pending: user_info.confirmation_pending,
	+ tags: user.tags,
	+ is_moderator: user.info.is_moderator,
	+ is_admin: user.info.is_admin,
	+ relationship: relationship
	+ }
	+ \|> with_notification_settings(user, opts[:for])
	}
	end

	defp username_from_nickname(string) when is_binary(string) do
	hd(String.split(string, "@"))
	end

	defp username_from_nickname(_), do: nil
	+
	+ defp with_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
	+ Map.put(data, :notification_settings, user.info.notification_settings)
	+ end
	+
	+ defp with_notification_settings(data, _, _), do: data
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 4c0b53bdd..d4a8e4fff 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,396 +1,417 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusView do
	use Pleroma.Web, :view

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy

	# TODO: Add cached version.
	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	%{data: %{"type" => "Create", "object" => %{"inReplyTo" => in_reply_to}}} ->
	in_reply_to != "" && in_reply_to

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

	defp get_user(ap_id) do
	cond do
	user = User.get_cached_by_ap_id(ap_id) ->
	user

	user = User.get_by_guessed_nickname(ap_id) ->
	user

	true ->
	User.error_user(ap_id)
	end
	end

	defp get_context_id(%{data: %{"context_id" => context_id}}) when not is_nil(context_id),
	do: context_id

	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
	do: Utils.context_to_conversation_id(context)

	defp get_context_id(_), do: nil

	def render("index.json", opts) do
	replied_to_activities = get_replied_to_activities(opts.activities)

	opts.activities
	\|> safe_render_many(
	StatusView,
	"status.json",
	Map.put(opts, :replied_to_activities, replied_to_activities)
	)
	end

	def render(
	"status.json",
	%{activity: %{data: %{"type" => "Announce", "object" => object}} = activity} = opts
	) do
	user = get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])

	reblogged = Activity.get_create_by_object_ap_id(object)
	reblogged = render("status.json", Map.put(opts, :activity, reblogged))

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	%{
	id: to_string(activity.id),
	uri: object,
	url: object,
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	favourited: false,
	bookmarked: false,
	muted: false,
	pinned: pinned?(activity, user),
	sensitive: false,
	spoiler_text: "",
	visibility: "public",
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [],
	pleroma: %{
	local: activity.local
	}
	}
	end

	def render("status.json", %{activity: %{data: %{"object" => object}} = activity} = opts) do
	user = get_user(activity.data["actor"])

	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0

	tags = object["tag"] \|\| []
	sensitive = object["sensitive"] \|\| Enum.member?(tags, "nsfw")

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])
	favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])
	bookmarked = opts[:for] && object["id"] in opts[:for].bookmarks

	attachment_data = object["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object["published"])

	reply_to = get_reply_to(activity, opts)
	reply_to_user = reply_to && get_user(reply_to.data["actor"])

	content =
	object
	\|> render_content()
	+
	+ content_html =
	+ content
	\|> HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content"
	)

	- summary =
	- (object["summary"] \|\| "")
	+ content_plaintext =
	+ content
	+ \|> HTML.get_cached_stripped_html_for_activity(
	+ activity,
	+ "mastoapi:content"
	+ )
	+
	+ summary = object["summary"] \|\| ""
	+
	+ summary_html =
	+ summary
	\|> HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:summary"
	)

	+ summary_plaintext =
	+ summary
	+ \|> HTML.get_cached_stripped_html_for_activity(
	+ activity,
	+ "mastoapi:summary"
	+ )
	+
	card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	object["external_url"] \|\| object["id"]
	end

	%{
	id: to_string(activity.id),
	uri: object["id"],
	url: url,
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	- content: content,
	+ content: content_html,
	created_at: created_at,
	reblogs_count: announcement_count,
	replies_count: object["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: present?(repeated),
	favourited: present?(favorited),
	bookmarked: present?(bookmarked),
	muted: CommonAPI.thread_muted?(user, activity) \|\| User.mutes?(opts[:for], user),
	pinned: pinned?(activity, user),
	sensitive: sensitive,
	- spoiler_text: summary,
	+ spoiler_text: summary_html,
	visibility: get_visibility(object),
	media_attachments: attachments,
	mentions: mentions,
	tags: build_tags(tags),
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: build_emojis(activity.data["object"]["emoji"]),
	pleroma: %{
	local: activity.local,
	- conversation_id: get_context_id(activity)
	+ conversation_id: get_context_id(activity),
	+ content: %{"text/plain" => content_plaintext},
	+ spoiler_text: %{"text/plain" => summary_plaintext}
	}
	}
	end

	def render("status.json", _) do
	nil
	end

	def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
	page_url_data = URI.parse(page_url)

	page_url_data =
	if rich_media[:url] != nil do
	URI.merge(page_url_data, URI.parse(rich_media[:url]))
	else
	page_url_data
	end

	page_url = page_url_data \|> to_string

	image_url =
	if rich_media[:image] != nil do
	URI.merge(page_url_data, URI.parse(rich_media[:image]))
	\|> to_string
	else
	nil
	end

	site_name = rich_media[:site_name] \|\| page_url_data.host

	%{
	type: "link",
	provider_name: site_name,
	provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url \|> MediaProxy.url(),
	title: rich_media[:title],
	description: rich_media[:description],
	pleroma: %{
	opengraph: rich_media
	}
	}
	end

	def render("card.json", _) do
	nil
	end

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href = attachment_url["href"] \|> MediaProxy.url()

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)

	%{
	id: to_string(attachment["id"] \|\| hash_id),
	url: href,
	remote_url: href,
	preview_url: href,
	text_url: href,
	type: type,
	description: attachment["name"],
	pleroma: %{mime_type: media_type}
	}
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	_id = activity.data["object"]["inReplyTo"]
	replied_to_activities[activity.data["object"]["inReplyTo"]]
	end

	def get_reply_to(%{data: %{"object" => object}}, _) do
	if object["inReplyTo"] && object["inReplyTo"] != "" do
	Activity.get_create_by_object_ap_id(object["inReplyTo"])
	else
	nil
	end
	end

	def get_visibility(object) do
	public = "https://www.w3.org/ns/activitystreams#Public"
	to = object["to"] \|\| []
	cc = object["cc"] \|\| []

	cond do
	public in to ->
	"public"

	public in cc ->
	"unlisted"

	# this should use the sql for the object's activity
	Enum.any?(to, &String.contains?(&1, "/followers")) ->
	"private"

	length(cc) > 0 ->
	"private"

	true ->
	"direct"
	end
	end

	def render_content(%{"type" => "Video"} = object) do
	with name when not is_nil(name) and name != "" <- object["name"] do
	"<p><a href=\"#{object["id"]}\">#{name}</a></p>#{object["content"]}"
	else
	_ -> object["content"] \|\| ""
	end
	end

	def render_content(%{"type" => object_type} = object)
	when object_type in ["Article", "Page"] do
	with summary when not is_nil(summary) and summary != "" <- object["name"],
	url when is_bitstring(url) <- object["url"] do
	"<p><a href=\"#{url}\">#{summary}</a></p>#{object["content"]}"
	else
	_ -> object["content"] \|\| ""
	end
	end

	def render_content(object), do: object["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags = for tag when is_binary(tag) <- object_tags, do: tag

	Enum.reduce(object_tags, [], fn tag, tags ->
	tags ++ [%{name: tag, url: "/tag/#{tag}"}]
	end)
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

	%{shortcode: name, url: url, static_url: url, visible_in_picker: false}
	end)
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pinned?(%Activity{id: id}, %User{info: %{pinned_activities: pinned_activities}}),
	do: id in pinned_activities
	end
	diff --git a/lib/pleroma/web/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 ef38fc34d..172f337db 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,714 +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("/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)
	+ get("/invites", AdminAPIController, :invites)
	+ post("/revoke_invite", AdminAPIController, :revoke_invite)
	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)
	+ put("/notification_settings", UtilController, :update_notificaton_settings)
	end

	scope [] do
	pipe_through(:oauth_follow)

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

	scope [] do
	pipe_through(:oauth_read)

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

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

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

	scope [] do
	pipe_through(:browser)

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

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

	scope [] do
	pipe_through(:oauth_read)

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

	get("/accounts/relationships", MastodonAPIController, :relationships)
	get("/accounts/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)
	+
	+ post("/pleroma/accounts/:id/subscribe", MastodonAPIController, :subscribe)
	+ post("/pleroma/accounts/:id/unsubscribe", MastodonAPIController, :unsubscribe)
	end

	scope [] do
	pipe_through(:oauth_push)

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

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

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

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

	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/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index c21404434..dbabacc5d 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,354 +1,361 @@
	# 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_cached_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_cached_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_cached_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_cached_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
	emoji =
	Emoji.get_all()
	\|> Enum.map(fn {short_code, path, tags} ->
	- %{short_code => %{image_url: path, tags: String.split(tags, ",")}}
	+ {short_code, %{image_url: path, tags: String.split(tags, ",")}}
	end)
	+ \|> Enum.into(%{})

	json(conn, emoji)
	end

	+ def update_notificaton_settings(%{assigns: %{user: user}} = conn, params) do
	+ with {:ok, _} <- User.update_notification_settings(user, params) do
	+ json(conn, %{status: "success"})
	+ end
	+ 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
	case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
	{:ok, user} ->
	Task.start(fn -> User.delete(user) end)
	json(conn, %{status: "success"})

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

	def captcha(conn, _params) do
	json(conn, Pleroma.Captcha.new())
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index 1cd29a6eb..c998189d7 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,289 +1,302 @@
	# 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.TwitterAPI do
	alias Pleroma.Activity
	alias Pleroma.Mailer
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserEmail
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.TwitterAPI.UserView

	import Ecto.Query

	def create_status(%User{} = user, %{"status" => _} = data) do
	CommonAPI.post(user, data)
	end

	def delete(%User{} = user, id) do
	with %Activity{data: %{"type" => _type}} <- Activity.get_by_id(id),
	{:ok, activity} <- CommonAPI.delete(id, user) do
	{:ok, activity}
	end
	end

	def follow(%User{} = follower, params) do
	with {:ok, %User{} = followed} <- get_user(params) do
	CommonAPI.follow(follower, followed)
	end
	end

	def unfollow(%User{} = follower, params) do
	with {:ok, %User{} = unfollowed} <- get_user(params),
	{:ok, follower} <- CommonAPI.unfollow(follower, unfollowed) do
	{:ok, follower, unfollowed}
	end
	end

	def block(%User{} = blocker, params) do
	with {:ok, %User{} = blocked} <- get_user(params),
	{:ok, blocker} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	{:ok, blocker, blocked}
	else
	err -> err
	end
	end

	def unblock(%User{} = blocker, params) do
	with {:ok, %User{} = blocked} <- get_user(params),
	{:ok, blocker} <- User.unblock(blocker, blocked),
	{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	{:ok, blocker, blocked}
	else
	err -> err
	end
	end

	def repeat(%User{} = user, ap_id_or_id) do
	with {:ok, _announce, %{data: %{"id" => id}}} <- CommonAPI.repeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def unrepeat(%User{} = user, 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
	{:ok, activity}
	end
	end

	def pin(%User{} = user, ap_id_or_id) do
	CommonAPI.pin(ap_id_or_id, user)
	end

	def unpin(%User{} = user, ap_id_or_id) do
	CommonAPI.unpin(ap_id_or_id, user)
	end

	def fav(%User{} = user, 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
	{:ok, activity}
	end
	end

	def unfav(%User{} = user, ap_id_or_id) do
	with {:ok, _unfav, _fav, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def upload(%Plug.Upload{} = file, %User{} = user, format \\ "xml") do
	{:ok, object} = ActivityPub.upload(file, actor: User.ap_id(user))

	url = List.first(object.data["url"])
	href = url["href"]
	type = url["mediaType"]

	case format do
	"xml" ->
	# Fake this as good as possible...
	"""
	<?xml version="1.0" encoding="UTF-8"?>
	<rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
	<mediaid>#{object.id}</mediaid>
	<media_id>#{object.id}</media_id>
	<media_id_string>#{object.id}</media_id_string>
	<media_url>#{href}</media_url>
	<mediaurl>#{href}</mediaurl>
	<atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
	</rsp>
	"""

	"json" ->
	%{
	media_id: object.id,
	media_id_string: "#{object.id}}",
	media_url: href,
	size: 0
	}
	\|> Jason.encode!()
	end
	end

	def register_user(params) do
	- token_string = params["token"]
	+ token = params["token"]

	params = %{
	nickname: params["nickname"],
	name: params["fullname"],
	bio: User.parse_bio(params["bio"]),
	email: params["email"],
	password: params["password"],
	password_confirmation: params["confirm"],
	captcha_solution: params["captcha_solution"],
	captcha_token: params["captcha_token"],
	captcha_answer_data: params["captcha_answer_data"]
	}

	captcha_enabled = Pleroma.Config.get([Pleroma.Captcha, :enabled])
	# true if captcha is disabled or enabled and valid, false otherwise
	captcha_ok =
	if !captcha_enabled do
	:ok
	else
	Pleroma.Captcha.validate(
	params[:captcha_token],
	params[:captcha_solution],
	params[:captcha_answer_data]
	)
	end

	# Captcha invalid
	if captcha_ok != :ok do
	{:error, error} = captcha_ok
	# I have no idea how this error handling works
	{:error, %{error: Jason.encode!(%{captcha: [error]})}}
	else
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	+ registration_process(registrations_open, params, token)
	+ end
	+ end

	- # no need to query DB if registration is open
	- token =
	- unless registrations_open \|\| is_nil(token_string) do
	- Repo.get_by(UserInviteToken, %{token: token_string})
	- end
	+ defp registration_process(registration_open, params, token)
	+ when registration_open == false or is_nil(registration_open) do
	+ invite =
	+ unless is_nil(token) do
	+ Repo.get_by(UserInviteToken, %{token: token})
	+ end

	- cond do
	- registrations_open \|\| (!is_nil(token) && !token.used) ->
	- changeset = User.register_changeset(%User{}, params)
	+ valid_invite? = invite && UserInviteToken.valid_invite?(invite)

	- with {:ok, user} <- User.register(changeset) do
	- !registrations_open && UserInviteToken.mark_as_used(token.token)
	+ case invite do
	+ nil ->
	+ {:error, "Invalid token"}

	- {:ok, user}
	- else
	- {:error, changeset} ->
	- errors =
	- Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
	- \|> Jason.encode!()
	+ invite when valid_invite? ->
	+ UserInviteToken.update_usage!(invite)
	+ create_user(params)

	- {:error, %{error: errors}}
	- end
	+ _ ->
	+ {:error, "Expired token"}
	+ end
	+ end

	- !registrations_open && is_nil(token) ->
	- {:error, "Invalid token"}
	+ defp registration_process(true, params, _token) do
	+ create_user(params)
	+ end

	- !registrations_open && token.used ->
	- {:error, "Expired token"}
	- end
	+ defp create_user(params) do
	+ changeset = User.register_changeset(%User{}, params)
	+
	+ case User.register(changeset) do
	+ {:ok, user} ->
	+ {:ok, user}
	+
	+ {:error, changeset} ->
	+ errors =
	+ Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
	+ \|> Jason.encode!()
	+
	+ {:error, %{error: errors}}
	end
	end

	def password_reset(nickname_or_email) do
	with true <- is_binary(nickname_or_email),
	%User{local: true} = user <- User.get_by_nickname_or_email(nickname_or_email),
	{:ok, token_record} <- Pleroma.PasswordResetToken.create_token(user) do
	user
	\|> UserEmail.password_reset_email(token_record.token)
	\|> Mailer.deliver_async()
	else
	false ->
	{:error, "bad user identifier"}

	%User{local: false} ->
	{:error, "remote user"}

	nil ->
	{:error, "unknown user"}
	end
	end

	def get_user(user \\ nil, params) do
	case params do
	%{"user_id" => user_id} ->
	case target = User.get_cached_by_nickname_or_id(user_id) do
	nil ->
	{:error, "No user with such user_id"}

	_ ->
	{:ok, target}
	end

	%{"screen_name" => nickname} ->
	case User.get_cached_by_nickname(nickname) do
	nil -> {:error, "No user with such screen_name"}
	target -> {:ok, target}
	end

	_ ->
	if user do
	{:ok, user}
	else
	{:error, "You need to specify screen_name or user_id"}
	end
	end
	end

	defp parse_int(string, default)

	defp parse_int(string, default) when is_binary(string) do
	with {n, _} <- Integer.parse(string) do
	n
	else
	_e -> default
	end
	end

	defp parse_int(_, default), do: default

	def search(_user, %{"q" => query} = params) do
	limit = parse_int(params["rpp"], 20)
	page = parse_int(params["page"], 1)
	offset = (page - 1) * limit

	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: ^limit,
	offset: ^offset,
	# this one isn't indexed so psql won't take the wrong index.
	order_by: [desc: :inserted_at]
	)

	_activities = Repo.all(q)
	end

	def get_external_profile(for_user, uri) do
	with %User{} = user <- User.get_or_fetch(uri) do
	{:ok, UserView.render("show.json", %{user: user, for: for_user})}
	else
	_e ->
	{:error, "Couldn't find user"}
	end
	end
	end
	diff --git a/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs b/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs
	new file mode 100644
	index 000000000..211a14135
	--- /dev/null
	+++ b/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs
	@@ -0,0 +1,12 @@
	+defmodule Pleroma.Repo.Migrations.AddFieldsToUserInviteTokens do
	+ use Ecto.Migration
	+
	+ def change do
	+ alter table(:user_invite_tokens) do
	+ add(:expires_at, :date)
	+ add(:uses, :integer, default: 0)
	+ add(:max_use, :integer)
	+ add(:invite_type, :string, default: "one_time")
	+ end
	+ end
	+end
	diff --git a/priv/repo/migrations/20190405160700_add_index_on_subscribers.exs b/priv/repo/migrations/20190405160700_add_index_on_subscribers.exs
	new file mode 100644
	index 000000000..232f75c92
	--- /dev/null
	+++ b/priv/repo/migrations/20190405160700_add_index_on_subscribers.exs
	@@ -0,0 +1,8 @@
	+defmodule Pleroma.Repo.Migrations.AddIndexOnSubscribers do
	+ use Ecto.Migration
	+
	+ @disable_ddl_transaction true
	+ def change do
	+ create index(:users, ["(info->'subscribers')"], name: :users_subscribers_index, using: :gin, concurrently: true)
	+ end
	+end
	diff --git a/test/fixtures/lambadalambda.json b/test/fixtures/lambadalambda.json
	new file mode 100644
	index 000000000..1f09fb591
	--- /dev/null
	+++ b/test/fixtures/lambadalambda.json
	@@ -0,0 +1,64 @@
	+{
	+ "@context": [
	+ "https://www.w3.org/ns/activitystreams",
	+ "https://w3id.org/security/v1",
	+ {
	+ "manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
	+ "toot": "http://joinmastodon.org/ns#",
	+ "featured": {
	+ "@id": "toot:featured",
	+ "@type": "@id"
	+ },
	+ "alsoKnownAs": {
	+ "@id": "as:alsoKnownAs",
	+ "@type": "@id"
	+ },
	+ "movedTo": {
	+ "@id": "as:movedTo",
	+ "@type": "@id"
	+ },
	+ "schema": "http://schema.org#",
	+ "PropertyValue": "schema:PropertyValue",
	+ "value": "schema:value",
	+ "Hashtag": "as:Hashtag",
	+ "Emoji": "toot:Emoji",
	+ "IdentityProof": "toot:IdentityProof",
	+ "focalPoint": {
	+ "@container": "@list",
	+ "@id": "toot:focalPoint"
	+ }
	+ }
	+ ],
	+ "id": "https://mastodon.social/users/lambadalambda",
	+ "type": "Person",
	+ "following": "https://mastodon.social/users/lambadalambda/following",
	+ "followers": "https://mastodon.social/users/lambadalambda/followers",
	+ "inbox": "https://mastodon.social/users/lambadalambda/inbox",
	+ "outbox": "https://mastodon.social/users/lambadalambda/outbox",
	+ "featured": "https://mastodon.social/users/lambadalambda/collections/featured",
	+ "preferredUsername": "lambadalambda",
	+ "name": "Critical Value",
	+ "summary": "\u003cp\u003e\u003c/p\u003e",
	+ "url": "https://mastodon.social/@lambadalambda",
	+ "manuallyApprovesFollowers": false,
	+ "publicKey": {
	+ "id": "https://mastodon.social/users/lambadalambda#main-key",
	+ "owner": "https://mastodon.social/users/lambadalambda",
	+ "publicKeyPem": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAw0P/Tq4gb4G/QVuMGbJo\nC/AfMNcv+m7NfrlOwkVzcU47jgESuYI4UtJayissCdBycHUnfVUd9qol+eznSODz\nCJhfJloqEIC+aSnuEPGA0POtWad6DU0E6/Ho5zQn5WAWUwbRQqowbrsm/GHo2+3v\neR5jGenwA6sYhINg/c3QQbksyV0uJ20Umyx88w8+TJuv53twOfmyDWuYNoQ3y5cc\nHKOZcLHxYOhvwg3PFaGfFHMFiNmF40dTXt9K96r7sbzc44iLD+VphbMPJEjkMuf8\nPGEFOBzy8pm3wJZw2v32RNW2VESwMYyqDzwHXGSq1a73cS7hEnc79gXlELsK04L9\nQQIDAQAB\n-----END PUBLIC KEY-----\n"
	+ },
	+ "tag": [],
	+ "attachment": [],
	+ "endpoints": {
	+ "sharedInbox": "https://mastodon.social/inbox"
	+ },
	+ "icon": {
	+ "type": "Image",
	+ "mediaType": "image/gif",
	+ "url": "https://files.mastodon.social/accounts/avatars/000/000/264/original/1429214160519.gif"
	+ },
	+ "image": {
	+ "type": "Image",
	+ "mediaType": "image/gif",
	+ "url": "https://files.mastodon.social/accounts/headers/000/000/264/original/28b26104f83747d2.gif"
	+ }
	+}
	diff --git a/test/notification_test.exs b/test/notification_test.exs
	index 7904ed9e9..581db58a8 100644
	--- a/test/notification_test.exs
	+++ b/test/notification_test.exs
	@@ -1,415 +1,518 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase
	alias Pleroma.Notification
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	import Pleroma.Factory

	describe "create_notifications" do
	test "notifies someone when they are directly addressed" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname} and @#{third_user.nickname}"
	})

	{:ok, [notification, other_notification]} = Notification.create_notifications(activity)

	notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
	assert notified_ids == [other_user.id, third_user.id]
	assert notification.activity_id == activity.id
	assert other_notification.activity_id == activity.id
	end
	+
	+ test "it creates a notification for subscribed users" do
	+ user = insert(:user)
	+ subscriber = insert(:user)
	+
	+ User.subscribe(subscriber, user)
	+
	+ {:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
	+ {:ok, [notification]} = Notification.create_notifications(status)
	+
	+ assert notification.user_id == subscriber.id
	+ end
	end

	describe "create_notification" do
	test "it doesn't create a notification for user if the user blocks the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])
	user = insert(:user)
	{:ok, user} = User.block(user, author)

	assert nil == Notification.create_notification(activity, user)
	end

	+ test "it doesn't create a notificatin for the user if the user mutes the activity author" do
	+ muter = insert(:user)
	+ muted = insert(:user)
	+ {:ok, _} = User.mute(muter, muted)
	+ muter = Repo.get(User, muter.id)
	+ {:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})
	+
	+ assert nil == Notification.create_notification(activity, muter)
	+ end
	+
	+ test "it doesn't create a notification for an activity from a muted thread" do
	+ muter = insert(:user)
	+ other_user = insert(:user)
	+ {:ok, activity} = CommonAPI.post(muter, %{"status" => "hey"})
	+ CommonAPI.add_mute(muter, activity)
	+
	+ {:ok, activity} =
	+ CommonAPI.post(other_user, %{
	+ "status" => "Hi @#{muter.nickname}",
	+ "in_reply_to_status_id" => activity.id
	+ })
	+
	+ assert nil == Notification.create_notification(activity, muter)
	+ end
	+
	+ test "it disables notifications from people on remote instances" do
	+ user = insert(:user, info: %{notification_settings: %{"remote" => false}})
	+ other_user = insert(:user)
	+
	+ create_activity = %{
	+ "@context" => "https://www.w3.org/ns/activitystreams",
	+ "type" => "Create",
	+ "to" => ["https://www.w3.org/ns/activitystreams#Public"],
	+ "actor" => other_user.ap_id,
	+ "object" => %{
	+ "type" => "Note",
	+ "content" => "Hi @#{user.nickname}",
	+ "attributedTo" => other_user.ap_id
	+ }
	+ }
	+
	+ {:ok, %{local: false} = activity} = Transmogrifier.handle_incoming(create_activity)
	+ assert nil == Notification.create_notification(activity, user)
	+ end
	+
	+ test "it disables notifications from people on the local instance" do
	+ user = insert(:user, info: %{notification_settings: %{"local" => false}})
	+ other_user = insert(:user)
	+ {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
	+ assert nil == Notification.create_notification(activity, user)
	+ end
	+
	+ test "it disables notifications from followers" do
	+ follower = insert(:user)
	+ followed = insert(:user, info: %{notification_settings: %{"followers" => false}})
	+ User.follow(follower, followed)
	+ {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
	+ assert nil == Notification.create_notification(activity, followed)
	+ end
	+
	+ test "it disables notifications from people the user follows" do
	+ follower = insert(:user, info: %{notification_settings: %{"follows" => false}})
	+ followed = insert(:user)
	+ User.follow(follower, followed)
	+ follower = Repo.get(User, follower.id)
	+ {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
	+ assert nil == Notification.create_notification(activity, follower)
	+ end
	+
	test "it doesn't create a notification for user if he is the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])

	assert nil == Notification.create_notification(activity, author)
	end

	test "it doesn't create a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user)
	{:ok, _, _, activity} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
	Notification.create_notification(activity, followed_user)
	TwitterAPI.unfollow(user, %{"user_id" => followed_user.id})
	{:ok, _, _, activity_dupe} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
	assert nil == Notification.create_notification(activity_dupe, followed_user)
	end

	test "it doesn't create a notification for like-unlike-like chains" do
	user = insert(:user)
	liked_user = insert(:user)
	{:ok, status} = TwitterAPI.create_status(liked_user, %{"status" => "Yui is best yuru"})
	{:ok, fav_status} = TwitterAPI.fav(user, status.id)
	Notification.create_notification(fav_status, liked_user)
	TwitterAPI.unfav(user, status.id)
	{:ok, dupe} = TwitterAPI.fav(user, status.id)
	assert nil == Notification.create_notification(dupe, liked_user)
	end

	test "it doesn't create a notification for repeat-unrepeat-repeat chains" do
	user = insert(:user)
	retweeted_user = insert(:user)

	{:ok, status} =
	TwitterAPI.create_status(retweeted_user, %{
	"status" => "Send dupe notifications to the shadow realm"
	})

	{:ok, retweeted_activity} = TwitterAPI.repeat(user, status.id)
	Notification.create_notification(retweeted_activity, retweeted_user)
	TwitterAPI.unrepeat(user, status.id)
	{:ok, dupe} = TwitterAPI.repeat(user, status.id)
	assert nil == Notification.create_notification(dupe, retweeted_user)
	end
	+
	+ test "it doesn't create duplicate notifications for follow+subscribed users" do
	+ user = insert(:user)
	+ subscriber = insert(:user)
	+
	+ {:ok, _, _, _} = TwitterAPI.follow(subscriber, %{"user_id" => user.id})
	+ User.subscribe(subscriber, user)
	+ {:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
	+ {:ok, [_notif]} = Notification.create_notifications(status)
	+ end
	+
	+ test "it doesn't create subscription notifications if the recipient cannot see the status" do
	+ user = insert(:user)
	+ subscriber = insert(:user)
	+
	+ User.subscribe(subscriber, user)
	+
	+ {:ok, status} =
	+ TwitterAPI.create_status(user, %{"status" => "inwisible", "visibility" => "direct"})
	+
	+ assert {:ok, []} == Notification.create_notifications(status)
	+ end
	end

	describe "get notification" do
	test "it gets a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.get(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.get(user, notification.id)
	end
	end

	describe "dismiss notification" do
	test "it dismisses a notification that belongs to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:ok, notification} = Notification.dismiss(other_user, notification.id)

	assert notification.user_id == other_user.id
	end

	test "it returns error if the notification doesn't belong to the user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)
	{:error, _notification} = Notification.dismiss(user, notification.id)
	end
	end

	describe "clear notification" do
	test "it clears all notifications belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)

	{:ok, activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
	})

	{:ok, _notifs} = Notification.create_notifications(activity)
	Notification.clear(other_user)

	assert Notification.for_user(other_user) == []
	assert Notification.for_user(third_user) != []
	end
	end

	describe "set_read_up_to()" do
	test "it sets all notifications as read up to a specified notification ID" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey again @#{other_user.nickname}!"
	})

	[n2, n1] = notifs = Notification.for_user(other_user)
	assert length(notifs) == 2

	assert n2.id > n1.id

	{:ok, _activity} =
	TwitterAPI.create_status(user, %{
	"status" => "hey yet again @#{other_user.nickname}!"
	})

	Notification.set_read_up_to(other_user, n2.id)

	[n3, n2, n1] = Notification.for_user(other_user)

	assert n1.seen == true
	assert n2.seen == true
	assert n3.seen == false
	end
	end

	describe "notification target determination" do
	test "it sends notifications to addressed users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	assert other_user in Notification.get_notified_from_activity(activity)
	end

	test "it sends notifications to mentioned users in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"content" => "message with a Mention tag, but no explicit tagging",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => other_user.ap_id,
	"name" => other_user.nickname
	}
	],
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	assert other_user in Notification.get_notified_from_activity(activity)
	end

	test "it does not send notifications to users who are only cc in new messages" do
	user = insert(:user)
	other_user = insert(:user)

	create_activity = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [other_user.ap_id],
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"content" => "hi everyone",
	"attributedTo" => user.ap_id
	}
	}

	{:ok, activity} = Transmogrifier.handle_incoming(create_activity)

	assert other_user not in Notification.get_notified_from_activity(activity)
	end

	test "it does not send notification to mentioned users in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two, _} = CommonAPI.favorite(activity_one.id, third_user)

	assert other_user not in Notification.get_notified_from_activity(activity_two)
	end

	test "it does not send notification to mentioned users in announces" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, activity_one} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)

	assert other_user not in Notification.get_notified_from_activity(activity_two)
	end
	end

	describe "notification lifecycle" do
	test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _, _, _} = CommonAPI.unfavorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

	assert length(Notification.for_user(user)) == 1

	{:ok, _, _} = CommonAPI.unrepeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "liking an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.favorite(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "repeating an activity which is already deleted does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})

	assert Enum.empty?(Notification.for_user(user))

	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	assert Enum.empty?(Notification.for_user(user))

	{:error, _} = CommonAPI.repeat(activity.id, other_user)

	assert Enum.empty?(Notification.for_user(user))
	end

	test "replying to a deleted post without tagging does not generate a notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
	{:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)

	{:ok, _reply_activity} =
	CommonAPI.post(other_user, %{
	"status" => "test reply",
	"in_reply_to_status_id" => activity.id
	})

	assert Enum.empty?(Notification.for_user(user))
	end
	end
	end
	diff --git a/test/support/http_request_mock.ex b/test/support/http_request_mock.ex
	index d3b547d91..5b355bfe6 100644
	--- a/test/support/http_request_mock.ex
	+++ b/test/support/http_request_mock.ex
	@@ -1,787 +1,791 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule HttpRequestMock do
	require Logger

	def request(
	%Tesla.Env{
	url: url,
	method: method,
	headers: headers,
	query: query,
	body: body
	} = _env
	) do
	with {:ok, res} <- apply(__MODULE__, method, [url, query, body, headers]) do
	res
	else
	{_, _r} = error ->
	# Logger.warn(r)
	error
	end
	end

	# GET Requests
	#
	def get(url, query \\ [], body \\ [], headers \\ [])

	def get("https://osada.macgirvin.com/channel/mike", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/httpoison_mock/https___osada.macgirvin.com_channel_mike.json")
	}}
	end

	def get("https://mastodon.social/users/emelie/statuses/101849165031453009", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/status.emelie.json")
	}}
	end

	def get("https://mastodon.social/users/emelie", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/emelie.json")
	}}
	end

	def get(
	"https://mastodon.social/.well-known/webfinger?resource=https://mastodon.social/users/emelie",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/webfinger_emelie.json")
	}}
	end

	def get("https://mastodon.social/users/emelie.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/emelie.atom")
	}}
	end

	def get(
	"https://osada.macgirvin.com/.well-known/webfinger?resource=acct:mike@osada.macgirvin.com",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/mike@osada.macgirvin.com.json")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=https://social.heldscal.la/user/29191",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___social.heldscal.la_user_29191.xml")
	}}
	end

	def get("https://pawoo.net/users/pekorino.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pawoo.net_users_pekorino.atom")
	}}
	end

	def get(
	"https://pawoo.net/.well-known/webfinger?resource=acct:https://pawoo.net/users/pekorino",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pawoo.net_users_pekorino.xml")
	}}
	end

	def get(
	"https://social.stopwatchingus-heidelberg.de/api/statuses/user_timeline/18330.atom",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/atarifrosch_feed.xml")
	}}
	end

	def get(
	"https://social.stopwatchingus-heidelberg.de/.well-known/webfinger?resource=acct:https://social.stopwatchingus-heidelberg.de/user/18330",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/atarifrosch_webfinger.xml")
	}}
	end

	def get("https://mamot.fr/users/Skruyb.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___mamot.fr_users_Skruyb.atom")
	}}
	end

	def get(
	"https://mamot.fr/.well-known/webfinger?resource=acct:https://mamot.fr/users/Skruyb",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/skruyb@mamot.fr.atom")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=nonexistant@social.heldscal.la",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/nonexistant@social.heldscal.la.xml")
	}}
	end

	def get(
	"https://squeet.me/xrd/?uri=lain@squeet.me",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/lain_squeet.me_webfinger.xml")
	}}
	end

	def get(
	"https://mst3k.interlinked.me/users/luciferMysticus",
	_,
	_,
	Accept: "application/activity+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/lucifermysticus.json")
	}}
	end

	def get("https://prismo.news/@mxb", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___prismo.news__mxb.json")
	}}
	end

	def get(
	"https://hubzilla.example.org/channel/kaniini",
	_,
	_,
	Accept: "application/activity+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/kaniini@hubzilla.example.org.json")
	}}
	end

	def get("https://niu.moe/users/rye", _, _, Accept: "application/activity+json") do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/rye.json")
	}}
	end

	def get("http://mastodon.example.org/users/admin/statuses/100787282858396771", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/http___mastodon.example.org_users_admin_status_1234.json"
	)
	}}
	end

	def get("https://puckipedia.com/", _, _, Accept: "application/activity+json") do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/puckipedia.com.json")
	}}
	end

	def get("https://peertube.moe/accounts/7even", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/7even.json")
	}}
	end

	def get("https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/peertube.moe-vid.json")
	}}
	end

	def get("https://baptiste.gelez.xyz/@/BaptisteGelez", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/baptiste.gelex.xyz-user.json")
	}}
	end

	def get("https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/baptiste.gelex.xyz-article.json")
	}}
	end

	def get("http://mastodon.example.org/users/admin", _, _, Accept: "application/activity+json") do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/admin@mastdon.example.org.json")
	}}
	end

	def get(
	"http://mastodon.example.org/@admin/99541947525187367",
	_,
	_,
	Accept: "application/activity+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/mastodon-note-object.json")
	}}
	end

	def get("https://shitposter.club/notice/7369654", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/7369654.html")
	}}
	end

	def get("https://mstdn.io/users/mayuutann", _, _, Accept: "application/activity+json") do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/mayumayu.json")
	}}
	end

	def get(
	"https://mstdn.io/users/mayuutann/statuses/99568293732299394",
	_,
	_,
	Accept: "application/activity+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/mayumayupost.json")
	}}
	end

	def get("https://pleroma.soykaf.com/users/lain/feed.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___pleroma.soykaf.com_users_lain_feed.atom.xml"
	)
	}}
	end

	def get(url, _, _, Accept: "application/xrd+xml,application/jrd+json")
	when url in [
	"https://pleroma.soykaf.com/.well-known/webfinger?resource=acct:https://pleroma.soykaf.com/users/lain",
	"https://pleroma.soykaf.com/.well-known/webfinger?resource=https://pleroma.soykaf.com/users/lain"
	] do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___pleroma.soykaf.com_users_lain.xml")
	}}
	end

	def get("https://shitposter.club/api/statuses/user_timeline/1.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___shitposter.club_api_statuses_user_timeline_1.atom.xml"
	)
	}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger?resource=https://shitposter.club/user/1",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___shitposter.club_user_1.xml")
	}}
	end

	def get("https://shitposter.club/notice/2827873", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!("test/fixtures/httpoison_mock/https___shitposter.club_notice_2827873.html")
	}}
	end

	def get("https://shitposter.club/api/statuses/show/2827873.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___shitposter.club_api_statuses_show_2827873.atom.xml"
	)
	}}
	end

	def get("https://testing.pleroma.lol/objects/b319022a-4946-44c5-9de9-34801f95507b", _, _, _) do
	{:ok, %Tesla.Env{status: 200}}
	end

	def get("https://shitposter.club/api/statuses/user_timeline/5381.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/spc_5381.atom")
	}}
	end

	def get(
	"https://shitposter.club/.well-known/webfinger?resource=https://shitposter.club/user/5381",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/spc_5381_xrd.xml")
	}}
	end

	def get("http://shitposter.club/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/shitposter.club_host_meta")
	}}
	end

	def get("https://shitposter.club/api/statuses/show/7369654.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/7369654.atom")
	}}
	end

	def get("https://shitposter.club/notice/4027863", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/7369654.html")
	}}
	end

	def get("https://social.sakamoto.gq/users/eal/feed.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/sakamoto_eal_feed.atom")
	}}
	end

	def get("http://social.sakamoto.gq/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.sakamoto.gq_host_meta")
	}}
	end

	def get(
	"https://social.sakamoto.gq/.well-known/webfinger?resource=https://social.sakamoto.gq/users/eal",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/eal_sakamoto.xml")
	}}
	end

	def get(
	"https://social.sakamoto.gq/objects/0ccc1a2c-66b0-4305-b23a-7f7f2b040056",
	_,
	_,
	Accept: "application/atom+xml"
	) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/httpoison_mock/sakamoto.atom")}}
	end

	def get("http://mastodon.social/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/mastodon.social_host_meta")
	}}
	end

	def get(
	"https://mastodon.social/.well-known/webfinger?resource=https://mastodon.social/users/lambadalambda",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___mastodon.social_users_lambadalambda.xml"
	)
	}}
	end

	def get("http://gs.example.org/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/gs.example.org_host_meta")
	}}
	end

	def get(
	"http://gs.example.org/.well-known/webfinger?resource=http://gs.example.org:4040/index.php/user/1",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/http___gs.example.org_4040_index.php_user_1.xml"
	)
	}}
	end

	def get("http://gs.example.org/index.php/api/statuses/user_timeline/1.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/http__gs.example.org_index.php_api_statuses_user_timeline_1.atom.xml"
	)
	}}
	end

	def get("https://social.heldscal.la/api/statuses/user_timeline/29191.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___social.heldscal.la_api_statuses_user_timeline_29191.atom.xml"
	)
	}}
	end

	def get("http://squeet.me/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/httpoison_mock/squeet.me_host_meta")}}
	end

	def get(
	"https://squeet.me/xrd?uri=lain@squeet.me",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/lain_squeet.me_webfinger.xml")
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=shp@social.heldscal.la",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/shp@social.heldscal.la.xml")
	}}
	end

	def get("http://framatube.org/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/framatube.org_host_meta")
	}}
	end

	def get(
	"http://framatube.org/main/xrd?uri=framasoft@framatube.org",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/json"}],
	body: File.read!("test/fixtures/httpoison_mock/framasoft@framatube.org.json")
	}}
	end

	def get("http://gnusocial.de/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/gnusocial.de_host_meta")
	}}
	end

	def get(
	"http://gnusocial.de/main/xrd?uri=winterdienst@gnusocial.de",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/winterdienst_webfinger.json")
	}}
	end

	def get("http://status.alpicola.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/status.alpicola.com_host_meta")
	}}
	end

	def get("http://macgirvin.com/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/macgirvin.com_host_meta")
	}}
	end

	def get("http://gerzilla.de/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/gerzilla.de_host_meta")
	}}
	end

	def get(
	"https://gerzilla.de/xrd/?uri=kaniini@gerzilla.de",
	_,
	_,
	Accept: "application/xrd+xml,application/jrd+json"
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	headers: [{"content-type", "application/json"}],
	body: File.read!("test/fixtures/httpoison_mock/kaniini@gerzilla.de.json")
	}}
	end

	def get("https://social.heldscal.la/api/statuses/user_timeline/23211.atom", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body:
	File.read!(
	"test/fixtures/httpoison_mock/https___social.heldscal.la_api_statuses_user_timeline_23211.atom.xml"
	)
	}}
	end

	def get(
	"https://social.heldscal.la/.well-known/webfinger?resource=https://social.heldscal.la/user/23211",
	_,
	_,
	_
	) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/https___social.heldscal.la_user_23211.xml")
	}}
	end

	def get("http://social.heldscal.la/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.heldscal.la_host_meta")
	}}
	end

	def get("https://social.heldscal.la/.well-known/host-meta", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: File.read!("test/fixtures/httpoison_mock/social.heldscal.la_host_meta")
	}}
	end

	def get("https://mastodon.social/users/lambadalambda.atom", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/lambadalambda.atom")}}
	end

	+ def get("https://mastodon.social/users/lambadalambda", _, _, _) do
	+ {:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/lambadalambda.json")}}
	+ end
	+
	def get("https://social.heldscal.la/user/23211", _, _, Accept: "application/activity+json") do
	{:ok, Tesla.Mock.json(%{"id" => "https://social.heldscal.la/user/23211"}, status: 200)}
	end

	def get("http://example.com/ogp", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/ogp.html")}}
	end

	def get("http://example.com/malformed", _, _, _) do
	{:ok,
	%Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/malformed-data.html")}}
	end

	def get("http://example.com/empty", _, _, _) do
	{:ok, %Tesla.Env{status: 200, body: "hello"}}
	end

	def get("http://404.site" <> _, _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 404,
	body: ""
	}}
	end

	def get(url, query, body, headers) do
	{:error,
	"Not implemented the mock response for get #{inspect(url)}, #{query}, #{inspect(body)}, #{
	inspect(headers)
	}"}
	end

	# POST Requests
	#

	def post(url, query \\ [], body \\ [], headers \\ [])

	def post("http://example.org/needs_refresh", _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: ""
	}}
	end

	def post("http://200.site" <> _, _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 200,
	body: ""
	}}
	end

	def post("http://connrefused.site" <> _, _, _, _) do
	{:error, :connrefused}
	end

	def post("http://404.site" <> _, _, _, _) do
	{:ok,
	%Tesla.Env{
	status: 404,
	body: ""
	}}
	end

	def post(url, _query, _body, _headers) do
	{:error, "Not implemented the mock response for post #{inspect(url)}"}
	end
	end
	diff --git a/test/tasks/user_test.exs b/test/tasks/user_test.exs
	index 9318c58da..eaf4ecf84 100644
	--- a/test/tasks/user_test.exs
	+++ b/test/tasks/user_test.exs
	@@ -1,261 +1,341 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.UserTest do
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory
	import ExUnit.CaptureIO

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "running new" do
	test "user is created" do
	# just get random data
	unsaved = build(:user)

	# prepare to answer yes
	send(self(), {:mix_shell_input, :yes?, true})

	Mix.Tasks.Pleroma.User.run([
	"new",
	unsaved.nickname,
	unsaved.email,
	"--name",
	unsaved.name,
	"--bio",
	unsaved.bio,
	"--password",
	"test",
	"--moderator",
	"--admin"
	])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_received {:mix_shell, :yes?, [message]}
	assert message =~ "Continue"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "created"

	user = User.get_cached_by_nickname(unsaved.nickname)
	assert user.name == unsaved.name
	assert user.email == unsaved.email
	assert user.bio == unsaved.bio
	assert user.info.is_moderator
	assert user.info.is_admin
	end

	test "user is not created" do
	unsaved = build(:user)

	# prepare to answer no
	send(self(), {:mix_shell_input, :yes?, false})

	Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_received {:mix_shell, :yes?, [message]}
	assert message =~ "Continue"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "will not be created"

	refute User.get_cached_by_nickname(unsaved.nickname)
	end
	end

	describe "running rm" do
	test "user is deleted" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["rm", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " deleted"

	user = User.get_cached_by_nickname(user.nickname)
	assert user.info.deactivated
	end

	test "no user to delete" do
	Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running toggle_activated" do
	test "user is deactivated" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " deactivated"

	user = User.get_cached_by_nickname(user.nickname)
	assert user.info.deactivated
	end

	test "user is activated" do
	user = insert(:user, info: %{deactivated: true})

	Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " activated"

	user = User.get_cached_by_nickname(user.nickname)
	refute user.info.deactivated
	end

	test "no user to toggle" do
	Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running unsubscribe" do
	test "user is unsubscribed" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Deactivating"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Unsubscribing"

	# Note that the task has delay :timer.sleep(500)
	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Successfully unsubscribed"

	user = User.get_cached_by_nickname(user.nickname)
	assert Enum.empty?(user.following)
	assert user.info.deactivated
	end

	test "no user to unsubscribe" do
	Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running set" do
	test "All statuses set" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* true/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* true/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* true/

	user = User.get_cached_by_nickname(user.nickname)
	assert user.info.is_moderator
	assert user.info.locked
	assert user.info.is_admin
	end

	test "All statuses unset" do
	user = insert(:user, info: %{is_moderator: true, locked: true, is_admin: true})

	Mix.Tasks.Pleroma.User.run([
	"set",
	user.nickname,
	"--no-moderator",
	"--no-admin",
	"--no-locked"
	])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* false/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* false/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* false/

	user = User.get_cached_by_nickname(user.nickname)
	refute user.info.is_moderator
	refute user.info.locked
	refute user.info.is_admin
	end

	test "no user to set status" do
	Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running reset_password" do
	test "password reset token is generated" do
	user = insert(:user)

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
	end) =~ "URL:"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated"
	end

	test "no user to reset password" do
	Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running invite" do
	test "invite token is generated" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["invite"])
	end) =~ "http"

	assert_received {:mix_shell, :info, [message]}
	- assert message =~ "Generated"
	+ assert message =~ "Generated user invite token one time"
	+ end
	+
	+ test "token is generated with expires_at" do
	+ assert capture_io(fn ->
	+ Mix.Tasks.Pleroma.User.run([
	+ "invite",
	+ "--expires-at",
	+ Date.to_string(Date.utc_today())
	+ ])
	+ end)
	+
	+ assert_received {:mix_shell, :info, [message]}
	+ assert message =~ "Generated user invite token date limited"
	+ end
	+
	+ test "token is generated with max use" do
	+ assert capture_io(fn ->
	+ Mix.Tasks.Pleroma.User.run([
	+ "invite",
	+ "--max-use",
	+ "5"
	+ ])
	+ end)
	+
	+ assert_received {:mix_shell, :info, [message]}
	+ assert message =~ "Generated user invite token reusable"
	+ end
	+
	+ test "token is generated with max use and expires date" do
	+ assert capture_io(fn ->
	+ Mix.Tasks.Pleroma.User.run([
	+ "invite",
	+ "--max-use",
	+ "5",
	+ "--expires-at",
	+ Date.to_string(Date.utc_today())
	+ ])
	+ end)
	+
	+ assert_received {:mix_shell, :info, [message]}
	+ assert message =~ "Generated user invite token reusable date limited"
	+ end
	+ end
	+
	+ describe "running invites" do
	+ test "invites are listed" do
	+ {:ok, invite} = Pleroma.UserInviteToken.create_invite()
	+
	+ {:ok, invite2} =
	+ Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 15})
	+
	+ # assert capture_io(fn ->
	+ Mix.Tasks.Pleroma.User.run([
	+ "invites"
	+ ])
	+
	+ # end)
	+
	+ assert_received {:mix_shell, :info, [message]}
	+ assert_received {:mix_shell, :info, [message2]}
	+ assert_received {:mix_shell, :info, [message3]}
	+ assert message =~ "Invites list:"
	+ assert message2 =~ invite.invite_type
	+ assert message3 =~ invite2.invite_type
	+ end
	+ end
	+
	+ describe "running revoke_invite" do
	+ test "invite is revoked" do
	+ {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
	+
	+ assert capture_io(fn ->
	+ Mix.Tasks.Pleroma.User.run([
	+ "revoke_invite",
	+ invite.token
	+ ])
	+ end)
	+
	+ assert_received {:mix_shell, :info, [message]}
	+ assert message =~ "Invite for token #{invite.token} was revoked."
	end
	end

	describe "running delete_activities" do
	test "activities are deleted" do
	%{nickname: nickname} = insert(:user)

	assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
	assert_received {:mix_shell, :info, [message]}
	assert message == "User #{nickname} statuses deleted."
	end
	end
	end
	diff --git a/test/user_invite_token_test.exs b/test/user_invite_token_test.exs
	new file mode 100644
	index 000000000..276788254
	--- /dev/null
	+++ b/test/user_invite_token_test.exs
	@@ -0,0 +1,96 @@
	+defmodule Pleroma.UserInviteTokenTest do
	+ use ExUnit.Case, async: true
	+ use Pleroma.DataCase
	+ alias Pleroma.UserInviteToken
	+
	+ describe "valid_invite?/1 one time invites" do
	+ setup do
	+ invite = %UserInviteToken{invite_type: "one_time"}
	+
	+ {:ok, invite: invite}
	+ end
	+
	+ test "not used returns true", %{invite: invite} do
	+ invite = %{invite \| used: false}
	+ assert UserInviteToken.valid_invite?(invite)
	+ end
	+
	+ test "used returns false", %{invite: invite} do
	+ invite = %{invite \| used: true}
	+ refute UserInviteToken.valid_invite?(invite)
	+ end
	+ end
	+
	+ describe "valid_invite?/1 reusable invites" do
	+ setup do
	+ invite = %UserInviteToken{
	+ invite_type: "reusable",
	+ max_use: 5
	+ }
	+
	+ {:ok, invite: invite}
	+ end
	+
	+ test "with less uses then max use returns true", %{invite: invite} do
	+ invite = %{invite \| uses: 4}
	+ assert UserInviteToken.valid_invite?(invite)
	+ end
	+
	+ test "with equal or more uses then max use returns false", %{invite: invite} do
	+ invite = %{invite \| uses: 5}
	+
	+ refute UserInviteToken.valid_invite?(invite)
	+
	+ invite = %{invite \| uses: 6}
	+
	+ refute UserInviteToken.valid_invite?(invite)
	+ end
	+ end
	+
	+ describe "valid_token?/1 date limited invites" do
	+ setup do
	+ invite = %UserInviteToken{invite_type: "date_limited"}
	+ {:ok, invite: invite}
	+ end
	+
	+ test "expires today returns true", %{invite: invite} do
	+ invite = %{invite \| expires_at: Date.utc_today()}
	+ assert UserInviteToken.valid_invite?(invite)
	+ end
	+
	+ test "expires yesterday returns false", %{invite: invite} do
	+ invite = %{invite \| expires_at: Date.add(Date.utc_today(), -1)}
	+ invite = Repo.insert!(invite)
	+ refute UserInviteToken.valid_invite?(invite)
	+ end
	+ end
	+
	+ describe "valid_token?/1 reusable date limited invites" do
	+ setup do
	+ invite = %UserInviteToken{invite_type: "reusable_date_limited", max_use: 5}
	+ {:ok, invite: invite}
	+ end
	+
	+ test "not overdue date and less uses returns true", %{invite: invite} do
	+ invite = %{invite \| expires_at: Date.utc_today(), uses: 4}
	+ assert UserInviteToken.valid_invite?(invite)
	+ end
	+
	+ test "overdue date and less uses returns false", %{invite: invite} do
	+ invite = %{invite \| expires_at: Date.add(Date.utc_today(), -1)}
	+ invite = Repo.insert!(invite)
	+ refute UserInviteToken.valid_invite?(invite)
	+ end
	+
	+ test "not overdue date with more uses returns false", %{invite: invite} do
	+ invite = %{invite \| expires_at: Date.utc_today(), uses: 5}
	+ refute UserInviteToken.valid_invite?(invite)
	+ end
	+
	+ test "overdue date with more uses returns false", %{invite: invite} do
	+ invite = %{invite \| expires_at: Date.add(Date.utc_today(), -1), uses: 5}
	+ invite = Repo.insert!(invite)
	+ refute UserInviteToken.valid_invite?(invite)
	+ end
	+ end
	+end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 314364a6d..37599927f 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,1128 +1,1170 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserTest do
	alias Pleroma.Activity
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase

	import Pleroma.Factory

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

	describe "when tags are nil" do
	test "tagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.tag(user, ["cool", "dude"])

	assert "cool" in user.tags
	assert "dude" in user.tags
	end

	test "untagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.untag(user, ["cool", "dude"])

	assert user.tags == []
	end
	end

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "returns all pending follow requests" do
	unlocked = insert(:user)
	locked = insert(:user, %{info: %{locked: true}})
	follower = insert(:user)

	Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => unlocked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => locked.id})

	assert {:ok, []} = User.get_follow_requests(unlocked)
	assert {:ok, [activity]} = User.get_follow_requests(locked)

	assert activity
	end

	test "doesn't return already accepted or duplicate follow requests" do
	locked = insert(:user, %{info: %{locked: true}})
	pending_follower = insert(:user)
	accepted_follower = insert(:user)

	Pleroma.Web.TwitterAPI.TwitterAPI.follow(pending_follower, %{"user_id" => locked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(pending_follower, %{"user_id" => locked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(accepted_follower, %{"user_id" => locked.id})
	User.maybe_follow(accepted_follower, locked)

	assert {:ok, [activity]} = User.get_follow_requests(locked)
	assert activity
	end

	test "follow_all follows mutliple users" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	blocked = insert(:user)
	not_followed = insert(:user)
	reverse_blocked = insert(:user)

	{:ok, user} = User.block(user, blocked)
	{:ok, reverse_blocked} = User.block(reverse_blocked, user)

	{:ok, user} = User.follow(user, followed_zero)

	{:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])

	assert User.following?(user, followed_one)
	assert User.following?(user, followed_two)
	assert User.following?(user, followed_zero)
	refute User.following?(user, not_followed)
	refute User.following?(user, blocked)
	refute User.following?(user, reverse_blocked)
	end

	test "follow_all follows mutliple users without duplicating" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)

	{:ok, user} = User.follow_all(user, [followed_zero, followed_one])
	assert length(user.following) == 3

	{:ok, user} = User.follow_all(user, [followed_one, followed_two])
	assert length(user.following) == 4
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user} = User.follow(user, followed)

	user = User.get_cached_by_id(user.id)

	followed = User.get_cached_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	assert User.ap_followers(followed) in user.following
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, info: %{deactivated: true})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	+ test "can't subscribe to a user who blocked us" do
	+ blocker = insert(:user)
	+ blocked = insert(:user)
	+
	+ {:ok, blocker} = User.block(blocker, blocked)
	+
	+ {:error, _} = User.subscribe(blocked, blocker)
	+ end
	+
	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, info: %{locked: true})
	followed = insert(:user, info: %{locked: true})

	{:ok, follower} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	# This is a somewhat useless test.
	# test "following a remote user will ensure a websub subscription is present" do
	# user = insert(:user)
	# {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")

	# assert followed.local == false

	# {:ok, user} = User.follow(user, followed)
	# assert User.ap_followers(followed) in user.following

	# query = from w in WebsubClientSubscription,
	# where: w.topic == ^followed.info["topic"]
	# websub = Repo.one(query)

	# assert websub
	# end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	{:ok, user, _activity} = User.unfollow(user, followed)

	user = User.get_cached_by_id(user.id)

	assert user.following == []
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	user = User.get_cached_by_id(user.id)
	assert user.following == [user.ap_id]
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	test "fetches correct profile for nickname beginning with number" do
	# Use old-style integer ID to try to reproduce the problem
	user = insert(:user, %{id: 1080})
	userwithnumbers = insert(:user, %{nickname: "#{user.id}garbage"})
	assert userwithnumbers == User.get_cached_by_nickname_or_id(userwithnumbers.nickname)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	test "it autofollows accounts that are set for it" do
	user = insert(:user)
	remote_user = insert(:user, %{local: false})

	Pleroma.Config.put([:instance, :autofollowed_nicknames], [
	user.nickname,
	remote_user.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(registered_user, user)
	refute User.following?(registered_user, remote_user)

	Pleroma.Config.put([:instance, :autofollowed_nicknames], [])
	end

	test "it sends a welcome message if it is set" do
	welcome_user = insert(:user)

	Pleroma.Config.put([:instance, :welcome_user_nickname], welcome_user.nickname)
	Pleroma.Config.put([:instance, :welcome_message], "Hello, this is a cool site")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	assert activity.data["object"]["content"] =~ "cool site"
	assert activity.actor == welcome_user.ap_id

	Pleroma.Config.put([:instance, :welcome_user_nickname], nil)
	Pleroma.Config.put([:instance, :welcome_message], nil)
	end

	test "it requires an email, name, nickname and password, bio is optional" do
	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it restricts certain nicknames" do
	[restricted_name \| _] = Pleroma.Config.get([Pleroma.User, :restricted_nicknames])

	assert is_bitstring(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_name)

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

	refute changeset.valid?
	end

	test "it sets the password_hash, ap_id and following fields" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})

	assert changeset.changes[:following] == [
	User.ap_followers(%User{nickname: @full_user_data.nickname})
	]

	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end

	test "it ensures info is not nil" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	{:ok, user} =
	changeset
	\|> Repo.insert()

	refute is_nil(user.info)
	end
	end

	describe "user registration, with :account_activation_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	:ok
	end

	test "it creates unconfirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

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

	assert user.info.confirmation_pending
	assert user.info.confirmation_token
	end

	test "it creates confirmed user if :confirmed option is given" do
	changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
	assert changeset.valid?

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

	refute user.info.confirmation_pending
	refute user.info.confirmation_token
	end
	end

	describe "get_or_fetch/1" do
	test "gets an existing user by nickname" do
	user = insert(:user)
	fetched_user = User.get_or_fetch(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user by ap_id" do
	ap_id = "http://mastodon.example.org/users/admin"

	user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: ap_id,
	info: %{}
	)

	fetched_user = User.get_or_fetch(ap_id)
	freshed_user = refresh_record(user)
	assert freshed_user == fetched_user
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	fetched_user = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	fetched_user = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname" do
	user = insert(:user)

	fetched_user =
	User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname, case insensitive" do
	user = insert(:user, nickname: "nick")
	casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	fetched_user = User.get_or_fetch_by_nickname(casing_altered_fqn)

	assert user == fetched_user
	end

	test "fetches an external user via ostatus if no user exists" do
	fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
	assert fetched_user.nickname == "shp@social.heldscal.la"
	end

	test "returns nil if no user could be fetched" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == nil
	end

	test "returns nil for nonexistant local user" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == nil
	end

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago,
	info: %{}
	)

	assert orig_user.last_refreshed_at == a_week_ago

	user = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
	assert user.info.source_data["endpoints"]

	refute user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user creation changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	info: %{some: "info"},
	avatar: %{some: "avatar"}
	}

	test "it confirms validity" do
	cs = User.remote_user_creation(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_creation(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_creation(%{@valid_remote \| nickname: "bla"})
	assert cs.changes.local == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:name, :ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_creation(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it restricts some sizes" do
	[bio: 5000, name: 100]
	\|> Enum.each(fn {field, size} ->
	string = String.pad_leading(".", size)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	assert cs.valid?

	string = String.pad_leading(".", size + 1)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	refute cs.valid?
	end)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one} = User.follow(follower_one, user)
	{:ok, follower_two} = User.follow(follower_two, user)

	{:ok, res} = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

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

	followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
	followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the info->note_count property" do
	note = insert(:note)

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

	assert user.info.note_count == 0

	{:ok, user} = User.update_note_count(user)

	assert user.info.note_count == 1
	end

	test "it increases the info->note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 2
	end

	test "it decreases the info->note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 1

	{:ok, user} = User.decrease_note_count(user)

	assert user.info.note_count == 0

	{:ok, user} = User.decrease_note_count(user)

	assert user.info.note_count == 0
	end

	test "it sets the info->follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.info.follower_count == 0

	{:ok, user} = User.update_follower_count(user)

	assert user.info.follower_count == 1
	end
	end

	describe "follow_import" do
	test "it imports user followings from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	result = User.follow_import(user1, identifiers)
	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	describe "mutes" do
	test "it mutes people" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)

	{:ok, user} = User.mute(user, muted_user)

	assert User.mutes?(user, muted_user)
	end

	test "it unmutes users" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, user} = User.mute(user, muted_user)
	{:ok, user} = User.unmute(user, muted_user)

	refute User.mutes?(user, muted_user)
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

	{:ok, user} = User.block(user, blocked_user)

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, user} = User.block(user, blocked_user)
	{:ok, user} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end
	+
	+ test "blocks tear down blocked->blocker subscription relationships" do
	+ blocker = insert(:user)
	+ blocked = insert(:user)
	+
	+ {:ok, blocker} = User.subscribe(blocked, blocker)
	+
	+ assert User.subscribed_to?(blocked, blocker)
	+ refute User.subscribed_to?(blocker, blocked)
	+
	+ {:ok, blocker} = User.block(blocker, blocked)
	+
	+ assert User.blocks?(blocker, blocked)
	+ refute User.subscribed_to?(blocker, blocked)
	+ refute User.subscribed_to?(blocked, blocker)
	+ end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end
	end

	describe "blocks_import" do
	test "it imports user blocks from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	result = User.blocks_import(user1, identifiers)
	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	test "get recipients from activity" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, user} = User.follow(user, actor)
	{:ok, _user_two} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 3
	assert user in recipients
	assert addressed in recipients
	end

	test ".deactivate can de-activate then re-activate a user" do
	user = insert(:user)
	assert false == user.info.deactivated
	{:ok, user} = User.deactivate(user)
	assert true == user.info.deactivated
	{:ok, user} = User.deactivate(user, false)
	assert false == user.info.deactivated
	end

	test ".delete_user_activities deletes all create activities" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
	{:ok, _} = User.delete_user_activities(user)

	# TODO: Remove favorites, repeats, delete activities.
	refute Activity.get_by_id(activity.id)
	end

	test ".delete deactivates a user, all follow relationships and all create activities" do
	user = insert(:user)
	followed = insert(:user)
	follower = insert(:user)

	{:ok, user} = User.follow(user, followed)
	{:ok, follower} = User.follow(follower, user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
	{:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})

	{:ok, _, _} = CommonAPI.favorite(activity_two.id, user)
	{:ok, _, _} = CommonAPI.favorite(activity.id, follower)
	{:ok, _, _} = CommonAPI.repeat(activity.id, follower)

	{:ok, _} = User.delete(user)

	followed = User.get_cached_by_id(followed.id)
	follower = User.get_cached_by_id(follower.id)
	user = User.get_cached_by_id(user.id)

	assert user.info.deactivated

	refute User.following?(user, followed)
	refute User.following?(followed, follower)

	# TODO: Remove favorites, repeats, delete activities.

	refute Activity.get_by_id(activity.id)
	end

	test "get_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	test "insert or update a user from given data" do
	user = insert(:user, %{nickname: "nick@name.de"})
	data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns default policies, when rich-text is enabled" do
	user = insert(:user)

	assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, %{info: %{no_rich_text: true}})

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)
	_user_info = User.get_cached_user_info(user)

	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	{:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

	{:ok, _} = User.delete(user)

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	describe "User.search" do
	test "finds a user by full or partial nickname" do
	user = insert(:user, %{nickname: "john"})

	Enum.each(["john", "jo", "j"], fn query ->
	assert user ==
	User.search(query)
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end)
	end

	test "finds a user by full or partial name" do
	user = insert(:user, %{name: "John Doe"})

	Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
	assert user ==
	User.search(query)
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end)
	end

	test "finds users, preferring nickname matches over name matches" do
	u1 = insert(:user, %{name: "lain", nickname: "nick1"})
	u2 = insert(:user, %{nickname: "lain", name: "nick1"})

	assert [u2.id, u1.id] == Enum.map(User.search("lain"), & &1.id)
	end

	test "finds users, considering density of matched tokens" do
	u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
	u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})

	assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
	end

	test "finds users, ranking by similarity" do
	u1 = insert(:user, %{name: "lain"})
	_u2 = insert(:user, %{name: "ean"})
	u3 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
	u4 = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})

	assert [u4.id, u3.id, u1.id] == Enum.map(User.search("lain@ple"), & &1.id)
	end

	test "finds users, handling misspelled requests" do
	u1 = insert(:user, %{name: "lain"})

	assert [u1.id] == Enum.map(User.search("laiin"), & &1.id)
	end

	test "finds users, boosting ranks of friends and followers" do
	u1 = insert(:user)
	u2 = insert(:user, %{name: "Doe"})
	follower = insert(:user, %{name: "Doe"})
	friend = insert(:user, %{name: "Doe"})

	{:ok, follower} = User.follow(follower, u1)
	{:ok, u1} = User.follow(u1, friend)

	assert [friend.id, follower.id, u2.id] --
	Enum.map(User.search("doe", resolve: false, for_user: u1), & &1.id) == []
	end

	test "finds a user whose name is nil" do
	_user = insert(:user, %{name: "notamatch", nickname: "testuser@pleroma.amplifie.red"})
	user_two = insert(:user, %{name: nil, nickname: "lain@pleroma.soykaf.com"})

	assert user_two ==
	User.search("lain@pleroma.soykaf.com")
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end

	test "does not yield false-positive matches" do
	insert(:user, %{name: "John Doe"})

	Enum.each(["mary", "a", ""], fn query ->
	assert [] == User.search(query)
	end)
	end

	test "works with URIs" do
	results = User.search("http://mastodon.example.org/users/admin", resolve: true)
	result = results \|> List.first()

	user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")

	assert length(results) == 1
	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end
	end

	test "auth_active?/1 works correctly" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	local_user = insert(:user, local: true, info: %{confirmation_pending: true})
	confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
	remote_user = insert(:user, local: false)

	refute User.auth_active?(local_user)
	assert User.auth_active?(confirmed_user)
	assert User.auth_active?(remote_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end

	describe "superuser?/1" do
	test "returns false for unprivileged users" do
	user = insert(:user, local: true)

	refute User.superuser?(user)
	end

	test "returns false for remote users" do
	user = insert(:user, local: false)
	remote_admin_user = insert(:user, local: false, info: %{is_admin: true})

	refute User.superuser?(user)
	refute User.superuser?(remote_admin_user)
	end

	test "returns true for local moderators" do
	user = insert(:user, local: true, info: %{is_moderator: true})

	assert User.superuser?(user)
	end

	test "returns true for local admins" do
	user = insert(:user, local: true, info: %{is_admin: true})

	assert User.superuser?(user)
	end
	end

	describe "visible_for?/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for?(user, user)
	end

	test "returns false when the account is unauthenticated and auth is required" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true)

	refute User.visible_for?(user, other_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end

	test "returns true when the account is unauthenticated and auth is not required" do
	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true)

	assert User.visible_for?(user, other_user)
	end

	test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true, info: %{is_admin: true})

	assert User.visible_for?(user, other_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	"A.k.a. <span class='h-card'><a data-user='#{remote_user.id}' class='u-url mention' href='#{
	remote_user.ap_id
	}'>" <> "@<span>nick@domain.com</span></a></span>"

	assert expected_text == User.parse_bio(bio, user)
	end

	test "Adds rel=me on linkbacked urls" do
	user = insert(:user, ap_id: "http://social.example.org/users/lain")

	bio = "http://example.org/rel_me/null"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.org/rel_me/link"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.org/rel_me/anchor"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "bookmarks" do
	user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	id1 = activity1.data["object"]["id"]

	{:ok, activity2} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	id2 = activity2.data["object"]["id"]

	assert {:ok, user_state1} = User.bookmark(user, id1)
	assert user_state1.bookmarks == [id1]

	assert {:ok, user_state2} = User.unbookmark(user, id1)
	assert user_state2.bookmarks == []

	assert {:ok, user_state3} = User.bookmark(user, id2)
	assert user_state3.bookmarks == [id2]
	end
	+
	+ test "follower count is updated when a follower is blocked" do
	+ user = insert(:user)
	+ follower = insert(:user)
	+ follower2 = insert(:user)
	+ follower3 = insert(:user)
	+
	+ {:ok, follower} = Pleroma.User.follow(follower, user)
	+ {:ok, _follower2} = Pleroma.User.follow(follower2, user)
	+ {:ok, _follower3} = Pleroma.User.follow(follower3, user)
	+
	+ {:ok, _} = Pleroma.User.block(user, follower)
	+
	+ user_show = Pleroma.Web.TwitterAPI.UserView.render("show.json", %{user: user})
	+
	+ assert Map.get(user_show, "followers_count") == 2
	+ 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 c57076ae3..cfe5f9095 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,643 +1,776 @@
	# 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
	+ alias Pleroma.UserInviteToken
	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)

	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_cached_by_id(user.id)
	follower = User.get_cached_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)

	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_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	end
	end

	describe "PUT /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=foo&tags[]=bar"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it appends specified tags to users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
	assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "DELETE /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=x&tags[]=z"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it removes specified tags from users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == []
	assert User.get_cached_by_id(user2.id).tags == ["y"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "/api/pleroma/admin/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_cached_by_id(user.id)
	assert user.info.deactivated == true
	assert json_response(conn, :no_content)
	end

	test "activates the user", %{conn: conn} do
	user = insert(:user, info: %{deactivated: true})

	conn =
	conn
	\|> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: true})

	user = User.get_cached_by_id(user.id)
	assert user.info.deactivated == false
	assert json_response(conn, :no_content)
	end

	test "returns 403 when requested by a non-admin", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/pleroma/admin/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
	+
	+ describe "GET /api/pleroma/admin/invite_token" do
	+ test "without options" do
	+ admin = insert(:user, info: %{is_admin: true})
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> get("/api/pleroma/admin/invite_token")
	+
	+ token = json_response(conn, 200)
	+ invite = UserInviteToken.find_by_token!(token)
	+ refute invite.used
	+ refute invite.expires_at
	+ refute invite.max_use
	+ assert invite.invite_type == "one_time"
	+ end
	+
	+ test "with expires_at" do
	+ admin = insert(:user, info: %{is_admin: true})
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> get("/api/pleroma/admin/invite_token", %{
	+ "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
	+ })
	+
	+ token = json_response(conn, 200)
	+ invite = UserInviteToken.find_by_token!(token)
	+
	+ refute invite.used
	+ assert invite.expires_at == Date.utc_today()
	+ refute invite.max_use
	+ assert invite.invite_type == "date_limited"
	+ end
	+
	+ test "with max_use" do
	+ admin = insert(:user, info: %{is_admin: true})
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> get("/api/pleroma/admin/invite_token", %{
	+ "invite" => %{"max_use" => 150}
	+ })
	+
	+ token = json_response(conn, 200)
	+ invite = UserInviteToken.find_by_token!(token)
	+ refute invite.used
	+ refute invite.expires_at
	+ assert invite.max_use == 150
	+ assert invite.invite_type == "reusable"
	+ end
	+
	+ test "with max use and expires_at" do
	+ admin = insert(:user, info: %{is_admin: true})
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> get("/api/pleroma/admin/invite_token", %{
	+ "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
	+ })
	+
	+ token = json_response(conn, 200)
	+ invite = UserInviteToken.find_by_token!(token)
	+ refute invite.used
	+ assert invite.expires_at == Date.utc_today()
	+ assert invite.max_use == 150
	+ assert invite.invite_type == "reusable_date_limited"
	+ end
	+ end
	+
	+ describe "GET /api/pleroma/admin/invites" do
	+ test "no invites" do
	+ admin = insert(:user, info: %{is_admin: true})
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> get("/api/pleroma/admin/invites")
	+
	+ assert json_response(conn, 200) == %{"invites" => []}
	+ end
	+
	+ test "with invite" do
	+ admin = insert(:user, info: %{is_admin: true})
	+ {:ok, invite} = UserInviteToken.create_invite()
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> get("/api/pleroma/admin/invites")
	+
	+ assert json_response(conn, 200) == %{
	+ "invites" => [
	+ %{
	+ "expires_at" => nil,
	+ "id" => invite.id,
	+ "invite_type" => "one_time",
	+ "max_use" => nil,
	+ "token" => invite.token,
	+ "used" => false,
	+ "uses" => 0
	+ }
	+ ]
	+ }
	+ end
	+ end
	+
	+ describe "POST /api/pleroma/admin/revoke_invite" do
	+ test "with token" do
	+ admin = insert(:user, info: %{is_admin: true})
	+ {:ok, invite} = UserInviteToken.create_invite()
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, admin)
	+ \|> post("/api/pleroma/admin/revoke_invite", %{"token" => invite.token})
	+
	+ assert json_response(conn, 200) == %{
	+ "expires_at" => nil,
	+ "id" => invite.id,
	+ "invite_type" => "one_time",
	+ "max_use" => nil,
	+ "token" => invite.token,
	+ "used" => true,
	+ "uses" => 0
	+ }
	+ end
	+ end
	end
	diff --git a/test/web/mastodon_api/account_view_test.exs b/test/web/mastodon_api/account_view_test.exs
	index 658606890..0730201bd 100644
	--- a/test/web/mastodon_api/account_view_test.exs
	+++ b/test/web/mastodon_api/account_view_test.exs
	@@ -1,213 +1,229 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.User
	alias Pleroma.Web.MastodonAPI.AccountView

	test "Represent a user account" do
	source_data = %{
	"tag" => [
	%{
	"type" => "Emoji",
	"icon" => %{"url" => "/file.png"},
	"name" => ":karjalanpiirakka:"
	}
	]
	}

	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 3, source_data: source_data},
	nickname: "shp@shitposter.club",
	name: ":karjalanpiirakka: shp",
	bio: "<script src=\"invalid-html\"></script><span>valid html</span>",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: "<span>valid html</span>",
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [
	%{
	"static_url" => "/file.png",
	"url" => "/file.png",
	"shortcode" => "karjalanpiirakka",
	"visible_in_picker" => false
	}
	],
	fields: [],
	bot: false,
	source: %{
	note: "",
	privacy: "public",
	sensitive: false
	},
	pleroma: %{
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	relationship: %{}
	}
	}

	assert expected == AccountView.render("account.json", %{user: user})
	end

	+ test "Represent the user account for the account owner" do
	+ user = insert(:user)
	+
	+ notification_settings = %{
	+ "remote" => true,
	+ "local" => true,
	+ "followers" => true,
	+ "follows" => true
	+ }
	+
	+ assert %{pleroma: %{notification_settings: ^notification_settings}} =
	+ AccountView.render("account.json", %{user: user, for: user})
	+ end
	+
	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 3, source_data: %{"type" => "Service"}},
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: "",
	privacy: "public",
	sensitive: false
	},
	pleroma: %{
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	relationship: %{}
	}
	}

	assert expected == AccountView.render("account.json", %{user: user})
	end

	test "Represent a smaller mention" do
	user = insert(:user)

	expected = %{
	id: to_string(user.id),
	acct: user.nickname,
	username: user.nickname,
	url: user.ap_id
	}

	assert expected == AccountView.render("mention.json", %{user: user})
	end

	test "represent a relationship" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, user} = User.block(user, other_user)

	expected = %{
	id: to_string(other_user.id),
	following: false,
	followed_by: false,
	blocking: true,
	muting: false,
	muting_notifications: false,
	+ subscribing: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	assert expected == AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent an embedded relationship" do
	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 0, source_data: %{"type" => "Service"}},
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	other_user = insert(:user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, other_user} = User.block(other_user, user)
	{:ok, _} = User.follow(insert(:user), user)

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 1,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: "",
	privacy: "public",
	sensitive: false
	},
	pleroma: %{
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	relationship: %{
	id: to_string(user.id),
	following: false,
	followed_by: false,
	blocking: true,
	+ subscribing: false,
	muting: false,
	muting_notifications: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}
	}
	}

	assert expected == AccountView.render("account.json", %{user: user, for: other_user})
	end
	end
	diff --git a/test/web/mastodon_api/mastodon_api_controller_test.exs b/test/web/mastodon_api/mastodon_api_controller_test.exs
	index eb7040366..ed6fc80a1 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,2637 +1,2656 @@
	# 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_cached_by_ap_id(activity.data["actor"])

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

	refute Activity.get_by_id(activity.id)
	end

	test "when you didn't create it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{"error" => _} = json_response(conn, 403)

	assert Activity.get_by_id(activity.id) == activity
	end

	test "when you're an admin or moderator", %{conn: conn} do
	activity1 = insert(:note_activity)
	activity2 = insert(:note_activity)
	admin = insert(:user, info: %{is_admin: true})
	moderator = insert(:user, info: %{is_moderator: true})

	res_conn =
	conn
	\|> assign(:user, admin)
	\|> delete("/api/v1/statuses/#{activity1.id}")

	assert %{} = json_response(res_conn, 200)

	res_conn =
	conn
	\|> assign(:user, moderator)
	\|> delete("/api/v1/statuses/#{activity2.id}")

	assert %{} = json_response(res_conn, 200)

	refute Activity.get_by_id(activity1.id)
	refute Activity.get_by_id(activity2.id)
	end
	end

	describe "filters" do
	test "creating a filter", %{conn: conn} do
	user = insert(:user)

	filter = %Pleroma.Filter{
	phrase: "knights",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

	assert response = json_response(conn, 200)
	assert response["phrase"] == filter.phrase
	assert response["context"] == filter.context
	assert response["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_cached_by_ap_id(note.data["actor"])

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")

	assert json_response(conn, 200) == []
	end

	test "gets an users media", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	media =
	TwitterAPI.upload(file, user, "json")
	\|> 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_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/follow_requests")

	assert [relationship] = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]
	end

	test "/api/v1/follow_requests/:id/authorize works" do
	user = insert(:user, %{info: %User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/authorize")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == true
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user, %{info: %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_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/reject")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	assert User.following?(other_user, user) == false
	end
	end

	test "account fetching", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(user.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/-1")

	assert %{"error" => "Can't find user"} = json_response(conn, 404)
	end

	test "account fetching also works nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == user.id
	end

	test "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_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unfollow")

	assert %{"id" => _id, "following" => false} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follows", %{"uri" => other_user.nickname})

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "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_cached_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 "subscribing / unsubscribing to a user", %{conn: conn} do
	+ user = insert(:user)
	+ subscription_target = insert(:user)
	+
	+ conn =
	+ conn
	+ \|> assign(:user, user)
	+ \|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")
	+
	+ assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, user)
	+ \|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")
	+
	+ assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
	+ end
	+
	test "getting a list of mutes", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.mute(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
	end

	test "getting a list of blocks", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.block(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a domain", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "getting a list of domain blocks", %{conn: conn} do
	user = insert(:user)

	{:ok, user} = User.block_domain(user, "bad.site")
	{:ok, user} = User.block_domain(user, "even.worse.site")

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/domain_blocks")

	domain_blocks = json_response(conn, 200)

	assert "bad.site" in domain_blocks
	assert "even.worse.site" in domain_blocks
	end

	test "unimplemented follow_requests, blocks, domain blocks" do
	user = insert(:user)

	["blocks", "domain_blocks", "follow_requests"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/#{endpoint}")

	assert [] = json_response(conn, 200)
	end)
	end

	test "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_cached_by_id(user.id)
	info_change = Changeset.change(user.info, %{deactivated: nil})

	{:ok, _user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> User.update_and_set_cache()

	Pleroma.Stats.update_stats()

	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/mastodon_api/status_view_test.exs b/test/web/mastodon_api/status_view_test.exs
	index 3661389de..e80f83269 100644
	--- a/test/web/mastodon_api/status_view_test.exs
	+++ b/test/web/mastodon_api/status_view_test.exs
	@@ -1,318 +1,320 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.OStatus
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	Repo.delete(user)
	Cachex.clear(:user_cache)

	%{account: ms_user} = StatusView.render("status.json", activity: activity)

	assert ms_user.acct == "erroruser@example.com"
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	Cachex.clear(:user_cache)

	result = StatusView.render("status.json", activity: activity)

	assert result[:account][:id] == to_string(user.id)
	end

	test "a note with null content" do
	note = insert(:note_activity)

	data =
	note.data
	\|> put_in(["object", "content"], nil)

	note =
	note
	\|> Map.put(:data, data)

	User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("status.json", %{activity: note})

	assert status.content == ""
	end

	test "a note activity" do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	convo_id = Utils.context_to_conversation_id(note.data["object"]["context"])

	status = StatusView.render("status.json", %{activity: note})

	created_at =
	(note.data["object"]["published"] \|\| "")
	\|> String.replace(~r/\.\d+Z/, ".000Z")

	expected = %{
	id: to_string(note.id),
	uri: note.data["object"]["id"],
	url: Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, note),
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	card: nil,
	reblog: nil,
	content: HtmlSanitizeEx.basic_html(note.data["object"]["content"]),
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	bookmarked: false,
	favourited: false,
	muted: false,
	pinned: false,
	sensitive: false,
	- spoiler_text: note.data["object"]["summary"],
	+ spoiler_text: HtmlSanitizeEx.basic_html(note.data["object"]["summary"]),
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [
	%{
	name: "#{note.data["object"]["tag"]}",
	url: "/tag/#{note.data["object"]["tag"]}"
	}
	],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	],
	pleroma: %{
	local: true,
	- conversation_id: convo_id
	+ conversation_id: convo_id,
	+ content: %{"text/plain" => HtmlSanitizeEx.strip_tags(note.data["object"]["content"])},
	+ spoiler_text: %{"text/plain" => HtmlSanitizeEx.strip_tags(note.data["object"]["summary"])}
	}
	}

	assert status == expected
	end

	test "tells if the message is muted for some reason" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.mute(user, other_user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "test"})
	status = StatusView.render("status.json", %{activity: activity})

	assert status.muted == false

	status = StatusView.render("status.json", %{activity: activity, for: user})

	assert status.muted == true
	end

	test "a reply" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "he", "in_reply_to_status_id" => note.id})

	status = StatusView.render("status.json", %{activity: activity})

	assert status.in_reply_to_id == to_string(note.id)

	[status] = StatusView.render("index.json", %{activities: [activity], as: :activity})

	assert status.in_reply_to_id == to_string(note.id)
	end

	test "contains mentions" do
	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	# a user with this ap id might be in the cache.
	recipient = "https://pleroma.soykaf.com/users/lain"
	user = insert(:user, %{ap_id: recipient})

	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	status = StatusView.render("status.json", %{activity: activity})

	actor = User.get_cached_by_ap_id(activity.actor)

	assert status.mentions ==
	Enum.map([user, actor], fn u -> AccountView.render("mention.json", %{user: u}) end)
	end

	test "attachments" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil,
	pleroma: %{mime_type: "image/png"}
	}

	assert expected == StatusView.render("attachment.json", %{attachment: object})

	# If theres a "id", use that instead of the generated one
	object = Map.put(object, "id", 2)
	assert %{id: "2"} = StatusView.render("attachment.json", %{attachment: object})
	end

	test "a reblog" do
	user = insert(:user)
	activity = insert(:note_activity)

	{:ok, reblog, _} = CommonAPI.repeat(activity.id, user)

	represented = StatusView.render("status.json", %{for: user, activity: reblog})

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	end

	test "a peertube video" do
	user = insert(:user)

	{:ok, object} =
	ActivityPub.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("status.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	end

	describe "build_tags/1" do
	test "it returns a a dictionary tags" do
	object_tags = [
	"fediverse",
	"mastodon",
	"nextcloud",
	%{
	"href" => "https://kawen.space/users/lain",
	"name" => "@lain@kawen.space",
	"type" => "Mention"
	}
	]

	assert StatusView.build_tags(object_tags) == [
	%{name: "fediverse", url: "/tag/fediverse"},
	%{name: "mastodon", url: "/tag/mastodon"},
	%{name: "nextcloud", url: "/tag/nextcloud"}
	]
	end
	end

	describe "rich media cards" do
	test "a rich media card without a site name renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	image: page_url <> "/example.jpg",
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card without a site name or image renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card without an image renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	site_name: "Example site name",
	title: "Example website"
	}

	%{provider_name: "Example site name"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card with all relevant data renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	site_name: "Example site name",
	title: "Example website",
	image: page_url <> "/example.jpg",
	description: "Example description"
	}

	%{provider_name: "Example site name"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	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/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index 68b11f5a0..c8be96a17 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,462 +1,675 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.UserView

	import Pleroma.Factory

	+ setup_all do
	+ Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	test "create a status" do
	user = insert(:user)
	mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})

	object_data = %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}

	object = Repo.insert!(%Object{data: object_data})

	input = %{
	"status" =>
	"Hello again, @shp.<script></script>\nThis is on another :moominmamma: line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	expected_text =
	"Hello again, <span class='h-card'><a data-user='#{mentioned_user.id}' class='u-url mention' href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :moominmamma: line. <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a class='hashtag' data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a class='hashtag' data-tag='phantasmagoric' href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"

	assert get_in(activity.data, ["object", "content"]) == expected_text
	assert get_in(activity.data, ["object", "type"]) == "Note"
	assert get_in(activity.data, ["object", "actor"]) == user.ap_id
	assert get_in(activity.data, ["actor"]) == user.ap_id
	assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))

	assert Enum.member?(
	get_in(activity.data, ["to"]),
	"https://www.w3.org/ns/activitystreams#Public"
	)

	assert Enum.member?(get_in(activity.data, ["to"]), "shp")
	assert activity.local == true

	assert %{"moominmamma" => "http://localhost:4001/finmoji/128px/moominmamma-128.png"} =
	activity.data["object"]["emoji"]

	# hashtags
	assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]

	# Add a context
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(activity.data, ["object", "context"]))

	assert is_list(activity.data["object"]["attachment"])

	assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.info.note_count == 1
	end

	test "create a status that is a reply" do
	user = insert(:user)

	input = %{
	"status" => "Hello again."
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])

	assert get_in(reply.data, ["object", "context"]) ==
	get_in(activity.data, ["object", "context"])

	assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
	assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
	end

	test "Follow another user using user_id" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert User.ap_followers(followed) in user.following

	{:error, msg} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Follow another user using screen_name" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} =
	TwitterAPI.follow(user, %{"screen_name" => followed.nickname})

	assert User.ap_followers(followed) in user.following

	followed = User.get_cached_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	{:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Unfollow another user using user_id" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert msg == "Not subscribed!"
	end

	test "Unfollow another user using screen_name" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})

	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert msg == "Not subscribed!"
	end

	test "Block another user using user_id" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
	assert User.blocks?(user, blocked)
	end

	test "Block another user using screen_name" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
	assert User.blocks?(user, blocked)
	end

	test "Unblock another user using user_id" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
	assert user.info.blocks == []
	end

	test "Unblock another user using screen_name" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
	assert user.info.blocks == []
	end

	test "upload a file" do
	user = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	response = TwitterAPI.upload(file, user)

	assert is_binary(response)
	end

	test "it favorites a status, returns the updated activity" do
	user = insert(:user)
	other_user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.fav(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 1

	object = Object.normalize(note_activity.data["object"])

	assert object.data["like_count"] == 1

	assert status == updated_activity

	{:ok, _status} = TwitterAPI.fav(other_user, note_activity.id)

	object = Object.normalize(note_activity.data["object"])

	assert object.data["like_count"] == 2

	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 2
	end

	test "it unfavorites a status, returns the updated activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, _like_activity, _object} = ActivityPub.like(user, object)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1

	{:ok, activity} = TwitterAPI.unfav(user, note_activity.id)

	assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
	end

	test "it retweets a status and returns the retweet" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.repeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it unretweets an already retweeted status" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, _status} = TwitterAPI.repeat(user, note_activity.id)
	{:ok, status} = TwitterAPI.unrepeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it registers a new user and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_cached_by_nickname("lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it registers a new user with empty string in bio and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_cached_by_nickname("lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	- @moduletag skip: "needs 'account_activation_required: true' in config"
	test "it sends confirmation email if :account_activation_required is specified in instance config" 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

	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	assert user.info.confirmation_pending

	Swoosh.TestAssertions.assert_email_sent(Pleroma.UserEmail.account_confirmation_email(user))
	end

	test "it registers a new user and parses mentions in the bio" do
	data1 = %{
	"nickname" => "john",
	"email" => "john@gmail.com",
	"fullname" => "John Doe",
	"bio" => "test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user1} = TwitterAPI.register_user(data1)

	data2 = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "@john test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user2} = TwitterAPI.register_user(data2)

	expected_text =
	"<span class='h-card'><a data-user='#{user1.id}' class='u-url mention' href='#{user1.ap_id}'>@<span>john</span></a></span> test"

	assert user2.bio == expected_text
	end

	- @moduletag skip: "needs 'registrations_open: false' in config"
	- test "it registers a new user via invite token and returns the user." do
	- {:ok, token} = UserInviteToken.create_token()
	+ describe "register with one time token" do
	+ setup do
	+ setting = Pleroma.Config.get([:instance, :registrations_open])

	- data = %{
	- "nickname" => "vinny",
	- "email" => "pasta@pizza.vs",
	- "fullname" => "Vinny Vinesauce",
	- "bio" => "streamer",
	- "password" => "hiptofbees",
	- "confirm" => "hiptofbees",
	- "token" => token.token
	- }
	+ if setting do
	+ Pleroma.Config.put([:instance, :registrations_open], false)
	+ on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	+ end

	- {:ok, user} = TwitterAPI.register_user(data)
	+ :ok
	+ end

	- fetched_user = User.get_cached_by_nickname("vinny")
	- token = Repo.get_by(UserInviteToken, token: token.token)
	+ test "returns user on success" do
	+ {:ok, invite} = UserInviteToken.create_invite()

	- assert token.used == true
	+ data = %{
	+ "nickname" => "vinny",
	+ "email" => "pasta@pizza.vs",
	+ "fullname" => "Vinny Vinesauce",
	+ "bio" => "streamer",
	+ "password" => "hiptofbees",
	+ "confirm" => "hiptofbees",
	+ "token" => invite.token
	+ }

	- assert UserView.render("show.json", %{user: user}) ==
	- UserView.render("show.json", %{user: fetched_user})
	+ {:ok, user} = TwitterAPI.register_user(data)
	+
	+ fetched_user = User.get_by_nickname("vinny")
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+
	+ assert invite.used == true
	+
	+ assert UserView.render("show.json", %{user: user}) ==
	+ UserView.render("show.json", %{user: fetched_user})
	+ end
	+
	+ test "returns error on invalid token" do
	+ data = %{
	+ "nickname" => "GrimReaper",
	+ "email" => "death@reapers.afterlife",
	+ "fullname" => "Reaper Grim",
	+ "bio" => "Your time has come",
	+ "password" => "scythe",
	+ "confirm" => "scythe",
	+ "token" => "DudeLetMeInImAFairy"
	+ }
	+
	+ {:error, msg} = TwitterAPI.register_user(data)
	+
	+ assert msg == "Invalid token"
	+ refute User.get_by_nickname("GrimReaper")
	+ end
	+
	+ test "returns error on expired token" do
	+ {:ok, invite} = UserInviteToken.create_invite()
	+ UserInviteToken.update_invite!(invite, used: true)
	+
	+ data = %{
	+ "nickname" => "GrimReaper",
	+ "email" => "death@reapers.afterlife",
	+ "fullname" => "Reaper Grim",
	+ "bio" => "Your time has come",
	+ "password" => "scythe",
	+ "confirm" => "scythe",
	+ "token" => invite.token
	+ }
	+
	+ {:error, msg} = TwitterAPI.register_user(data)
	+
	+ assert msg == "Expired token"
	+ refute User.get_by_nickname("GrimReaper")
	+ end
	end

	- @moduletag skip: "needs 'registrations_open: false' in config"
	- test "it returns an error if invalid token submitted" do
	- data = %{
	- "nickname" => "GrimReaper",
	- "email" => "death@reapers.afterlife",
	- "fullname" => "Reaper Grim",
	- "bio" => "Your time has come",
	- "password" => "scythe",
	- "confirm" => "scythe",
	- "token" => "DudeLetMeInImAFairy"
	- }
	+ describe "registers with date limited token" do
	+ setup do
	+ setting = Pleroma.Config.get([:instance, :registrations_open])
	+
	+ if setting do
	+ Pleroma.Config.put([:instance, :registrations_open], false)
	+ on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	+ end
	+
	+ data = %{
	+ "nickname" => "vinny",
	+ "email" => "pasta@pizza.vs",
	+ "fullname" => "Vinny Vinesauce",
	+ "bio" => "streamer",
	+ "password" => "hiptofbees",
	+ "confirm" => "hiptofbees"
	+ }
	+
	+ check_fn = fn invite ->
	+ data = Map.put(data, "token", invite.token)
	+ {:ok, user} = TwitterAPI.register_user(data)
	+ fetched_user = User.get_by_nickname("vinny")
	+
	+ assert UserView.render("show.json", %{user: user}) ==
	+ UserView.render("show.json", %{user: fetched_user})
	+ end
	+
	+ {:ok, data: data, check_fn: check_fn}
	+ end
	+
	+ test "returns user on success", %{check_fn: check_fn} do
	+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today()})
	+
	+ check_fn.(invite)
	+
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+
	+ refute invite.used
	+ end
	+
	+ test "returns user on token which expired tomorrow", %{check_fn: check_fn} do
	+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), 1)})
	+
	+ check_fn.(invite)
	+
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+
	+ refute invite.used
	+ end

	- {:error, msg} = TwitterAPI.register_user(data)
	+ test "returns an error on overdue date", %{data: data} do
	+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1)})

	- assert msg == "Invalid token"
	- refute User.get_cached_by_nickname("GrimReaper")
	+ data = Map.put(data, "token", invite.token)
	+
	+ {:error, msg} = TwitterAPI.register_user(data)
	+
	+ assert msg == "Expired token"
	+ refute User.get_by_nickname("vinny")
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+
	+ refute invite.used
	+ end
	end

	- @moduletag skip: "needs 'registrations_open: false' in config"
	- test "it returns an error if expired token submitted" do
	- {:ok, token} = UserInviteToken.create_token()
	- UserInviteToken.mark_as_used(token.token)
	+ describe "registers with reusable token" do
	+ setup do
	+ setting = Pleroma.Config.get([:instance, :registrations_open])

	- data = %{
	- "nickname" => "GrimReaper",
	- "email" => "death@reapers.afterlife",
	- "fullname" => "Reaper Grim",
	- "bio" => "Your time has come",
	- "password" => "scythe",
	- "confirm" => "scythe",
	- "token" => token.token
	- }
	+ if setting do
	+ Pleroma.Config.put([:instance, :registrations_open], false)
	+ on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	+ end
	+
	+ :ok
	+ end
	+
	+ test "returns user on success, after him registration fails" do
	+ {:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})
	+
	+ UserInviteToken.update_invite!(invite, uses: 99)
	+
	+ data = %{
	+ "nickname" => "vinny",
	+ "email" => "pasta@pizza.vs",
	+ "fullname" => "Vinny Vinesauce",
	+ "bio" => "streamer",
	+ "password" => "hiptofbees",
	+ "confirm" => "hiptofbees",
	+ "token" => invite.token
	+ }
	+
	+ {:ok, user} = TwitterAPI.register_user(data)
	+ fetched_user = User.get_by_nickname("vinny")
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+
	+ assert invite.used == true
	+
	+ assert UserView.render("show.json", %{user: user}) ==
	+ UserView.render("show.json", %{user: fetched_user})
	+
	+ data = %{
	+ "nickname" => "GrimReaper",
	+ "email" => "death@reapers.afterlife",
	+ "fullname" => "Reaper Grim",
	+ "bio" => "Your time has come",
	+ "password" => "scythe",
	+ "confirm" => "scythe",
	+ "token" => invite.token
	+ }
	+
	+ {:error, msg} = TwitterAPI.register_user(data)
	+
	+ assert msg == "Expired token"
	+ refute User.get_by_nickname("GrimReaper")
	+ end
	+ end
	+
	+ describe "registers with reusable date limited token" do
	+ setup do
	+ setting = Pleroma.Config.get([:instance, :registrations_open])
	+
	+ if setting do
	+ Pleroma.Config.put([:instance, :registrations_open], false)
	+ on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	+ end
	+
	+ :ok
	+ end
	+
	+ test "returns user on success" do
	+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
	+
	+ data = %{
	+ "nickname" => "vinny",
	+ "email" => "pasta@pizza.vs",
	+ "fullname" => "Vinny Vinesauce",
	+ "bio" => "streamer",
	+ "password" => "hiptofbees",
	+ "confirm" => "hiptofbees",
	+ "token" => invite.token
	+ }
	+
	+ {:ok, user} = TwitterAPI.register_user(data)
	+ fetched_user = User.get_by_nickname("vinny")
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+
	+ refute invite.used
	+
	+ assert UserView.render("show.json", %{user: user}) ==
	+ UserView.render("show.json", %{user: fetched_user})
	+ end
	+
	+ test "error after max uses" do
	+ {:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})
	+
	+ UserInviteToken.update_invite!(invite, uses: 99)
	+
	+ data = %{
	+ "nickname" => "vinny",
	+ "email" => "pasta@pizza.vs",
	+ "fullname" => "Vinny Vinesauce",
	+ "bio" => "streamer",
	+ "password" => "hiptofbees",
	+ "confirm" => "hiptofbees",
	+ "token" => invite.token
	+ }
	+
	+ {:ok, user} = TwitterAPI.register_user(data)
	+ fetched_user = User.get_by_nickname("vinny")
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+ assert invite.used == true
	+
	+ assert UserView.render("show.json", %{user: user}) ==
	+ UserView.render("show.json", %{user: fetched_user})
	+
	+ data = %{
	+ "nickname" => "GrimReaper",
	+ "email" => "death@reapers.afterlife",
	+ "fullname" => "Reaper Grim",
	+ "bio" => "Your time has come",
	+ "password" => "scythe",
	+ "confirm" => "scythe",
	+ "token" => invite.token
	+ }
	+
	+ {:error, msg} = TwitterAPI.register_user(data)
	+
	+ assert msg == "Expired token"
	+ refute User.get_by_nickname("GrimReaper")
	+ end
	+
	+ test "returns error on overdue date" do
	+ {:ok, invite} =
	+ UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})

	- {:error, msg} = TwitterAPI.register_user(data)

	- assert msg == "Expired token"
	- refute User.get_cached_by_nickname("GrimReaper")
	end

	test "it returns the error on registration problems" do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear"
	}

	{:error, error_object} = TwitterAPI.register_user(data)

	assert is_binary(error_object[:error])
	refute User.get_cached_by_nickname("lain")
	end

	test "it assigns an integer conversation_id" do
	note_activity = insert(:note_activity)
	status = ActivityView.render("activity.json", activity: note_activity)

	assert is_number(status["statusnet_conversation_id"])
	end

	setup do
	Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
	Supervisor.restart_child(Pleroma.Supervisor, Cachex)
	:ok
	end

	describe "fetching a user by uri" do
	test "fetches a user by uri" do
	id = "https://mastodon.social/users/lambadalambda"
	user = insert(:user)
	{:ok, represented} = TwitterAPI.get_external_profile(user, id)
	remote = User.get_cached_by_ap_id(id)

	assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

	# Also fetches the feed.
	# assert Activity.get_create_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	end
	end
	end
	diff --git a/test/web/twitter_api/util_controller_test.exs b/test/web/twitter_api/util_controller_test.exs
	index 410f20f87..a4b3d651a 100644
	--- a/test/web/twitter_api/util_controller_test.exs
	+++ b/test/web/twitter_api/util_controller_test.exs
	@@ -1,215 +1,233 @@
	defmodule Pleroma.Web.TwitterAPI.UtilControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Notification
	alias Pleroma.Repo
	+ alias Pleroma.User
	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 "PUT /api/pleroma/notification_settings" do
	+ test "it updates notification settings", %{conn: conn} do
	+ user = insert(:user)
	+
	+ conn
	+ \|> assign(:user, user)
	+ \|> put("/api/pleroma/notification_settings", %{
	+ "remote" => false,
	+ "followers" => false,
	+ "bar" => 1
	+ })
	+ \|> json_response(:ok)
	+
	+ user = Repo.get(User, user.id)
	+
	+ assert %{"remote" => false, "local" => true, "followers" => false, "follows" => true} ==
	+ user.info.notification_settings
	+ 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] =
	+ emoji =
	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)
	+ assert Enum.all?(emoji, fn
	+ {_key,
	+ %{
	+ "image_url" => url,
	+ "tags" => tags
	+ }} ->
	+ is_binary(url) and is_list(tags)
	+ end)
	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: Sun, Aug 9, 7:34 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1724330
Default Alt Text: (546 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions