No OneTemporary
Actions

Size

314 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/.formatter.exs b/.formatter.exs
	index 7fa95a619..5799ac127 100644
	--- a/.formatter.exs
	+++ b/.formatter.exs
	@@ -1,3 +1,3 @@
	[
	- inputs: ["mix.exs", "{config,lib,test}/*/.{ex,exs}", "priv/repo/migrations/*.exs"]
	+ inputs: ["mix.exs", "{config,lib,test}/*/.{ex,exs}", "priv/repo/migrations/.exs", "priv/scrubbers/.ex"]
	]
	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index d00097748..89044d046 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,494 +1,497 @@
	# Changelog
	All notable changes to this project will be documented in this file.

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

	## [Unreleased]
	### Removed
	- Breaking: Removed 1.0+ deprecated configurations `Pleroma.Upload, :strip_exif` and `:instance, :dedupe_media`
	- Breaking: OStatus protocol support

	### Changed
	- Breaking: Elixir >=1.8 is now required (was >= 1.7)
	- Breaking: attachment links (`config :pleroma, :instance, no_attachment_links` and `config :pleroma, Pleroma.Upload, link_name`) disabled by default
	- Replaced [pleroma_job_queue](https://git.pleroma.social/pleroma/pleroma_job_queue) and `Pleroma.Web.Federator.RetryQueue` with [Oban](https://github.com/sorentwo/oban) (see [`docs/config.md`](docs/config.md) on migrating customized worker / retry settings)
	- Introduced [quantum](https://github.com/quantum-elixir/quantum-core) job scheduler
	- Enabled `:instance, extended_nickname_format` in the default config
	- Add `rel="ugc"` to all links in statuses, to prevent SEO spam
	- Extract RSS functionality from OStatus
	- MRF (Simple Policy): Also use `:accept`/`:reject` on the actors rather than only their activities
	- OStatus: Extract RSS functionality
	- Deprecated `User.Info` embedded schema (fields moved to `User`)
	- Store status data inside Flag activity
	- Deprecated (reorganized as `UserRelationship` entity) User fields with user AP IDs (`blocks`, `mutes`, `muted_reblogs`, `muted_notifications`, `subscribers`).
	<details>
	<summary>API Changes</summary>

	- Breaking Admin API: `PATCH /api/pleroma/admin/users/:nickname/force_password_reset` is now `PATCH /api/pleroma/admin/users/force_password_reset` (accepts `nicknames` array in the request body)
	- Breaking: Admin API: Return link alongside with token on password reset
	- Breaking: Admin API: `PUT /api/pleroma/admin/reports/:id` is now `PATCH /api/pleroma/admin/reports`, see admin_api.md for details
	- Breaking: `/api/pleroma/admin/users/invite_token` now uses `POST`, changed accepted params and returns full invite in json instead of only token string.
	- Admin API: Return `total` when querying for reports
	- Mastodon API: Return `pleroma.direct_conversation_id` when creating a direct message (`POST /api/v1/statuses`)
	- Admin API: Return link alongside with token on password reset
	- Admin API: Support authentication via `x-admin-token` HTTP header
	- Mastodon API: Add `pleroma.direct_conversation_id` to the status endpoint (`GET /api/v1/statuses/:id`)
	- Mastodon API: `pleroma.thread_muted` to the Status entity
	- Mastodon API: Mark the direct conversation as read for the author when they send a new direct message
	- Mastodon API, streaming: Add `pleroma.direct_conversation_id` to the `conversation` stream event payload.
	- Admin API: Render whole status in grouped reports
	</details>

	### Added
	- `:chat_limit` option to limit chat characters.
	- Refreshing poll results for remote polls
	- Authentication: Added rate limit for password-authorized actions / login existence checks
	- Static Frontend: Add the ability to render user profiles and notices server-side without requiring JS app.
	- Mix task to re-count statuses for all users (`mix pleroma.count_statuses`)
	- Mix task to list all users (`mix pleroma.user list`)
	- Support for `X-Forwarded-For` and similar HTTP headers which used by reverse proxies to pass a real user IP address to the backend. Must not be enabled unless your instance is behind at least one reverse proxy (such as Nginx, Apache HTTPD or Varnish Cache).
	- MRF: New module which handles incoming posts based on their age. By default, all incoming posts that are older than 2 days will be unlisted and not shown to their followers.
	+- User notification settings: Add `privacy_option` option.
	<details>
	<summary>API Changes</summary>

	- Job queue stats to the healthcheck page
	- Admin API: Add ability to fetch reports, grouped by status `GET /api/pleroma/admin/grouped_reports`
	- Admin API: Add ability to require password reset
	- Mastodon API: Account entities now include `follow_requests_count` (planned Mastodon 3.x addition)
	- Pleroma API: `GET /api/v1/pleroma/accounts/:id/scrobbles` to get a list of recently scrobbled items
	- Pleroma API: `POST /api/v1/pleroma/scrobble` to scrobble a media item
	- Mastodon API: Add `upload_limit`, `avatar_upload_limit`, `background_upload_limit`, and `banner_upload_limit` to `/api/v1/instance`
	- Mastodon API: Add `pleroma.unread_conversation_count` to the Account entity
	- OAuth: support for hierarchical permissions / [Mastodon 2.4.3 OAuth permissions](https://docs.joinmastodon.org/api/permissions/)
	- Metadata Link: Atom syndication Feed
	- Mix task to re-count statuses for all users (`mix pleroma.count_statuses`)
	- Mastodon API: Add `exclude_visibilities` parameter to the timeline and notification endpoints
	- Admin API: `/users/:nickname/toggle_activation` endpoint is now deprecated in favor of: `/users/activate`, `/users/deactivate`, both accept `nicknames` array
	- Admin API: Multiple endpoints now require `nicknames` array, instead of singe `nickname`:
	- `POST/DELETE /api/pleroma/admin/users/:nickname/permission_group/:permission_group` are deprecated in favor of: `POST/DELETE /api/pleroma/admin/users/permission_group/:permission_group`
	- `DELETE /api/pleroma/admin/users` (`nickname` query param or `nickname` sent in JSON body) is deprecated in favor of: `DELETE /api/pleroma/admin/users` (`nicknames` query array param or `nicknames` sent in JSON body)
	- Admin API: Add `GET /api/pleroma/admin/relay` endpoint - lists all followed relays
	- Pleroma API: `POST /api/v1/pleroma/conversations/read` to mark all conversations as read
	- ActivityPub: Support `Move` activities
	- Mastodon API: Add `/api/v1/markers` for managing timeline read markers
	- Mastodon API: Add the `recipients` parameter to `GET /api/v1/conversations`
	- Configuration: `feed` option for user atom feed.
	- Pleroma API: Add Emoji reactions
	- Admin API: Add `/api/pleroma/admin/instances/:instance/statuses` - lists all statuses from a given instance
	- Admin API: `PATCH /api/pleroma/users/confirm_email` to confirm email for multiple users, `PATCH /api/pleroma/users/resend_confirmation_email` to resend confirmation email for multiple users
	</details>

	### Fixed
	- Report emails now include functional links to profiles of remote user accounts
	- Not being able to log in to some third-party apps when logged in to MastoFE
	- MRF: `Delete` activities being exempt from MRF policies
	+- OTP releases: Not being able to configure OAuth expired token cleanup interval
	+- OTP releases: Not being able to configure HTML sanitization policy
	<details>
	<summary>API Changes</summary>

	- Mastodon API: Fix private and direct statuses not being filtered out from the public timeline for an authenticated user (`GET /api/v1/timelines/public`)
	- Mastodon API: Inability to get some local users by nickname in `/api/v1/accounts/:id_or_nickname`
	- AdminAPI: If some status received reports both in the "new" format and "old" format it was considered reports on two different statuses (in the context of grouped reports)
	- Admin API: Error when trying to update reports in the "old" format
	</details>

	## [1.1.6] - 2019-11-19
	### Fixed
	- Not being able to log into to third party apps when the browser is logged into mastofe
	- Email confirmation not being required even when enabled
	- Mastodon API: conversations API crashing when one status is malformed

	### Bundled Pleroma-FE Changes
	#### Added
	- About page
	- Meme arrows

	#### Fixed
	- Image modal not closing unless clicked outside of image
	- Attachment upload spinner not being centered
	- Showing follow counters being 0 when they are actually hidden

	## [1.1.5] - 2019-11-09
	### Fixed
	- Polls having different numbers in timelines/notifications/poll api endpoints due to cache desyncronization
	- Pleroma API: OAuth token endpoint not being found when ".json" suffix is appended

	### Changed
	- Frontend bundle updated to [044c9ad0](https://git.pleroma.social/pleroma/pleroma-fe/commit/044c9ad0562af059dd961d50961a3880fca9c642)

	## [1.1.4] - 2019-11-01
	### Fixed
	- Added a migration that fills up empty user.info fields to prevent breakage after previous unsafe migrations.
	- Failure to migrate from pre-1.0.0 versions
	- Mastodon API: Notification stream not including follow notifications

	## [1.1.3] - 2019-10-25
	### Fixed
	- Blocked users showing up in notifications collapsed as if they were muted
	- `pleroma_ctl` not working on Debian's default shell

	## [1.1.2] - 2019-10-18
	### Fixed
	- `pleroma_ctl` trying to connect to a running instance when generating the config, which of course doesn't exist.

	## [1.1.1] - 2019-10-18
	### Fixed
	- One of the migrations between 1.0.0 and 1.1.0 wiping user info of the relay user because of unexpected behavior of postgresql's `jsonb_set`, resulting in inability to post in the default configuration. If you were affected, please run the following query in postgres console, the relay user will be recreated automatically:
	```
	delete from users where ap_id = 'https://your.instance.hostname/relay';
	```
	- Bad user search matches

	## [1.1.0] - 2019-10-14
	Breaking: The stable branch has been changed from `master` to `stable`. If you want to keep using 1.0, the `release/1.0` branch will receive security updates for 6 months after 1.1 release.

	OTP Note: `pleroma_ctl` in 1.0 defaults to `master` and doesn't support specifying arbitrary branches, making `./pleroma_ctl update` fail. To fix this, fetch a version of `pleroma_ctl` from 1.1 using the command below and proceed with the update normally:
	```
	curl -Lo ./bin/pleroma_ctl 'https://git.pleroma.social/pleroma/pleroma/raw/develop/rel/files/bin/pleroma_ctl'
	```
	### Security
	- Mastodon API: respect post privacy in `/api/v1/statuses/:id/{favourited,reblogged}_by`

	### Removed
	- Breaking: GNU Social API with Qvitter extensions support
	- Emoji: Remove longfox emojis.
	- Remove `Reply-To` header from report emails for admins.
	- ActivityPub: The `/objects/:uuid/likes` endpoint.

	### Changed
	- Breaking: Configuration: A setting to explicitly disable the mailer was added, defaulting to true, if you are using a mailer add `config :pleroma, Pleroma.Emails.Mailer, enabled: true` to your config
	- Breaking: Configuration: `/media/` is now removed when `base_url` is configured, append `/media/` to your `base_url` config to keep the old behaviour if desired
	- Breaking: `/api/pleroma/notifications/read` is moved to `/api/v1/pleroma/notifications/read` and now supports `max_id` and responds with Mastodon API entities.
	- Configuration: added `config/description.exs`, from which `docs/config.md` is generated
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- Federation: Return 403 errors when trying to request pages from a user's follower/following collections if they have `hide_followers`/`hide_follows` set
	- NodeInfo: Return `skipThreadContainment` in `metadata` for the `skip_thread_containment` option
	- NodeInfo: Return `mailerEnabled` in `metadata`
	- Mastodon API: Unsubscribe followers when they unfollow a user
	- Mastodon API: `pleroma.thread_muted` key in the Status entity
	- AdminAPI: Add "godmode" while fetching user statuses (i.e. admin can see private statuses)
	- Improve digest email template
	– Pagination: (optional) return `total` alongside with `items` when paginating
	- The `Pleroma.FlakeId` module has been replaced with the `flake_id` library.

	### Fixed
	- Following from Osada
	- Favorites timeline doing database-intensive queries
	- Metadata rendering errors resulting in the entire page being inaccessible
	- `federation_incoming_replies_max_depth` option being ignored in certain cases
	- Mastodon API: Handling of search timeouts (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API: Misskey's endless polls being unable to render
	- Mastodon API: Embedded relationships not being properly rendered in the Account entity of Status entity
	- Mastodon API: Notifications endpoint crashing if one notification failed to render
	- Mastodon API: `exclude_replies` is correctly handled again.
	- Mastodon API: Add `account_id`, `type`, `offset`, and `limit` to search API (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API, streaming: Fix filtering of notifications based on blocks/mutes/thread mutes
	- Mastodon API: Fix private and direct statuses not being filtered out from the public timeline for an authenticated user (`GET /api/v1/timelines/public`)
	- Mastodon API: Ensure the `account` field is not empty when rendering Notification entities.
	- Mastodon API: Inability to get some local users by nickname in `/api/v1/accounts/:id_or_nickname`
	- Mastodon API: Blocks are now treated consistently between the Streaming API and the Timeline APIs
	- Rich Media: Parser failing when no TTL can be found by image TTL setters
	- Rich Media: The crawled URL is now spliced into the rich media data.
	- ActivityPub S2S: sharedInbox usage has been mostly aligned with the rules in the AP specification.
	- ActivityPub C2S: follower/following collection pages being inaccessible even when authentifucated if `hide_followers`/ `hide_follows` was set
	- ActivityPub: Deactivated user deletion
	- ActivityPub: Fix `/users/:nickname/inbox` crashing without an authenticated user
	- MRF: fix ability to follow a relay when AntiFollowbotPolicy was enabled
	- ActivityPub: Correct addressing of Undo.
	- ActivityPub: Correct addressing of profile update activities.
	- ActivityPub: Polls are now refreshed when necessary.
	- Report emails now include functional links to profiles of remote user accounts
	- Existing user id not being preserved on insert conflict
	- Pleroma.Upload base_url was not automatically whitelisted by MediaProxy. Now your custom CDN or file hosting will be accessed directly as expected.
	- Report email not being sent to admins when the reporter is a remote user
	- Reverse Proxy limiting `max_body_length` was incorrectly defined and only checked `Content-Length` headers which may not be sufficient in some circumstances

	### Added
	- Expiring/ephemeral activites. All activities can have expires_at value set, which controls when they should be deleted automatically.
	- Mastodon API: in post_status, the expires_in parameter lets you set the number of seconds until an activity expires. It must be at least one hour.
	- Mastodon API: all status JSON responses contain a `pleroma.expires_at` item which states when an activity will expire. The value is only shown to the user who created the activity. To everyone else it's empty.
	- Configuration: `ActivityExpiration.enabled` controls whether expired activites will get deleted at the appropriate time. Enabled by default.
	- Conversations: Add Pleroma-specific conversation endpoints and status posting extensions. Run the `bump_all_conversations` task again to create the necessary data.
	- MRF: Support for priming the mediaproxy cache (`Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`)
	- MRF: Support for excluding specific domains from Transparency.
	- MRF: Support for filtering posts based on who they mention (`Pleroma.Web.ActivityPub.MRF.MentionPolicy`)
	- Mastodon API: Support for the [`tagged` filter](https://github.com/tootsuite/mastodon/pull/9755) in [`GET /api/v1/accounts/:id/statuses`](https://docs.joinmastodon.org/api/rest/accounts/#get-api-v1-accounts-id-statuses)
	- Mastodon API, streaming: Add support for passing the token in the `Sec-WebSocket-Protocol` header
	- Mastodon API, extension: Ability to reset avatar, profile banner, and background
	- Mastodon API: Add support for `fields_attributes` API parameter (setting custom fields)
	- Mastodon API: Add support for categories for custom emojis by reusing the group feature. <https://github.com/tootsuite/mastodon/pull/11196>
	- Mastodon API: Add support for muting/unmuting notifications
	- Mastodon API: Add support for the `blocked_by` attribute in the relationship API (`GET /api/v1/accounts/relationships`). <https://github.com/tootsuite/mastodon/pull/10373>
	- Mastodon API: Add support for the `domain_blocking` attribute in the relationship API (`GET /api/v1/accounts/relationships`).
	- Mastodon API: Add `pleroma.deactivated` to the Account entity
	- Mastodon API: added `/auth/password` endpoint for password reset with rate limit.
	- Mastodon API: /api/v1/accounts/:id/statuses now supports nicknames or user id
	- Mastodon API: Improve support for the user profile custom fields
	- Mastodon API: Add support for `fields_attributes` API parameter (setting custom fields)
	- Mastodon API: Added an endpoint to get multiple statuses by IDs (`GET /api/v1/statuses/?ids[]=1&ids[]=2`)
	- Admin API: Return users' tags when querying reports
	- Admin API: Return avatar and display name when querying users
	- Admin API: Allow querying user by ID
	- Admin API: Added support for `tuples`.
	- Admin API: Added endpoints to run mix tasks pleroma.config migrate_to_db & pleroma.config migrate_from_db
	- Added synchronization of following/followers counters for external users
	- Configuration: `enabled` option for `Pleroma.Emails.Mailer`, defaulting to `false`.
	- Configuration: Pleroma.Plugs.RateLimiter `bucket_name`, `params` options.
	- Configuration: `user_bio_length` and `user_name_length` options.
	- Addressable lists
	- Twitter API: added rate limit for `/api/account/password_reset` endpoint.
	- ActivityPub: Add an internal service actor for fetching ActivityPub objects.
	- ActivityPub: Optional signing of ActivityPub object fetches.
	- Admin API: Endpoint for fetching latest user's statuses
	- Pleroma API: Add `/api/v1/pleroma/accounts/confirmation_resend?email=<email>` for resending account confirmation.
	- Pleroma API: Email change endpoint.
	- Admin API: Added moderation log
	- Web response cache (currently, enabled for ActivityPub)
	- Reverse Proxy: Do not retry failed requests to limit pressure on the peer

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

	## [1.0.7] - 2019-09-26
	### Fixed
	- Broken federation on Erlang 22 (previous versions of hackney http client were using an option that got deprecated)
	### Changed
	- ActivityPub: The first page in inboxes/outboxes is no longer embedded.

	## [1.0.6] - 2019-08-14
	### Fixed
	- MRF: fix use of unserializable keyword lists in describe() implementations
	- ActivityPub S2S: POST requests are now signed with `(request-target)` pseudo-header.

	## [1.0.5] - 2019-08-13
	### Fixed
	- Mastodon API: follower/following counters not being nullified, when `hide_follows`/`hide_followers` is set
	- Mastodon API: `muted` in the Status entity, using author's account to determine if the thread was muted
	- Mastodon API: return the actual profile URL in the Account entity's `url` property when appropriate
	- Templates: properly style anchor tags
	- Objects being re-embedded to activities after being updated (e.g faved/reposted). Running 'mix pleroma.database prune_objects' again is advised.
	- Not being able to access the Mastodon FE login page on private instances
	- MRF: ensure that subdomain_match calls are case-insensitive
	- Fix internal server error when using the healthcheck API.

	### Added
	- Breaking: MRF describe API, which adds support for exposing configuration information about MRF policies to NodeInfo.
	Custom modules will need to be updated by adding, at the very least, `def describe, do: {:ok, %{}}` to the MRF policy modules.
	- Relays: Added a task to list relay subscriptions.
	- MRF: Support for filtering posts based on ActivityStreams vocabulary (`Pleroma.Web.ActivityPub.MRF.VocabularyPolicy`)
	- MRF (Simple Policy): Support for wildcard domains.
	- Support for wildcard domains in user domain blocks setting.
	- Configuration: `quarantined_instances` support wildcard domains.
	- Mix Tasks: `mix pleroma.database fix_likes_collections`
	- Configuration: `federation_incoming_replies_max_depth` option

	### Removed
	- Federation: Remove `likes` from objects.
	- Breaking: ActivityPub: The `accept_blocks` configuration setting.

	## [1.0.4] - 2019-08-01
	### Fixed
	- Invalid SemVer version generation, when the current branch does not have commits ahead of tag/checked out on a tag

	## [1.0.3] - 2019-07-31
	### Security
	- OStatus: eliminate the possibility of a protocol downgrade attack.
	- OStatus: prevent following locked accounts, bypassing the approval process.
	- TwitterAPI: use CommonAPI to handle remote follows instead of OStatus.

	## [1.0.2] - 2019-07-28
	### Fixed
	- Not being able to pin unlisted posts
	- Mastodon API: represent poll IDs as strings
	- MediaProxy: fix matching filenames
	- MediaProxy: fix filename encoding
	- Migrations: fix a sporadic migration failure
	- Metadata rendering errors resulting in the entire page being inaccessible
	- Federation/MediaProxy not working with instances that have wrong certificate order
	- ActivityPub S2S: remote user deletions now work the same as local user deletions.

	### Changed
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text

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

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

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

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

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

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

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

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

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

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

	## [0.9.9] - 2019-02-22
	This is our first stable release.
	diff --git a/docs/API/differences_in_mastoapi_responses.md b/docs/API/differences_in_mastoapi_responses.md
	index 006d17c1b..566789ec7 100644
	--- a/docs/API/differences_in_mastoapi_responses.md
	+++ b/docs/API/differences_in_mastoapi_responses.md
	@@ -1,171 +1,172 @@
	# 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.
	Adding the parameter `exclude_visibilities` to the timeline queries will exclude the statuses with the given visibilities. The parameter accepts an array of visibility types (`public`, `unlisted`, `private`, `direct`), e.g., `exclude_visibilities[]=direct&exclude_visibilities[]=private`.

	## Statuses

	- `visibility`: has an additional possible value `list`

	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 AP context the status is associated with (if any)
	- `direct_conversation_id`: the ID of the Mastodon direct message conversation the status is associated with (if any)
	- `in_reply_to_account_acct`: the `acct` property of User entity for replied user (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`
	- `expires_at`: a datetime (iso8601) that states when the post will expire (be deleted automatically), or empty if the post won't expire
	- `thread_muted`: true if the thread the post belongs to is muted

	## Attachments

	Has these additional fields under the `pleroma` object:

	- `mime_type`: mime type of the attachment.

	## Accounts

	The `id` parameter can also be the `nickname` of the user. This only works in these endpoints, not the deeper nested ones for following etc.

	- `/api/v1/accounts/:id`
	- `/api/v1/accounts/:id/statuses`

	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, nullable, true if user is a moderator
	- `is_admin`: boolean, nullable, true if user is an admin
	- `confirmation_pending`: boolean, true if a new user account is waiting on email confirmation to be activated
	- `hide_followers`: boolean, true when the user has follower hiding enabled
	- `hide_follows`: boolean, true when the user has follow hiding enabled
	- `hide_followers_count`: boolean, true when the user has follower stat hiding enabled
	- `hide_follows_count`: boolean, true when the user has follow stat hiding enabled
	- `settings_store`: A generic map of settings for frontends. Opaque to the backend. Only returned in `verify_credentials` and `update_credentials`
	- `chat_token`: The token needed for Pleroma chat. Only returned in `verify_credentials`
	- `deactivated`: boolean, true when the user is deactivated
	- `allow_following_move`: boolean, true when the user allows automatically follow moved following accounts
	- `unread_conversation_count`: The count of unread conversations. Only returned to the account owner.

	### Source

	Has these additional fields under the `pleroma` object:

	- `show_role`: boolean, nullable, true when the user wants his role (e.g admin, moderator) to be shown
	- `no_rich_text` - boolean, nullable, true when html tags are stripped from all statuses requested from the API

	## Conversations

	Has an additional field under the `pleroma` object:

	- `recipients`: The list of the recipients of this Conversation. These will be addressed when replying to this conversation.

	## GET `/api/v1/conversations`

	Accepts additional parameters:

	- `recipients`: Only return conversations with the given recipients (a list of user ids). Usage example: `GET /api/v1/conversations?recipients[]=1&recipients[]=2`

	## Account Search

	Behavior has changed:

	- `/api/v1/accounts/search`: Does not require authentication


	## Notifications

	Has these additional fields under the `pleroma` object:

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

	### Move Notification

	The `type` value is `move`. Has an additional field:

	- `target`: new account

	## GET `/api/v1/notifications`

	Accepts additional parameters:

	- `exclude_visibilities`: will exclude the notifications for activities with the given visibilities. The parameter accepts an array of visibility types (`public`, `unlisted`, `private`, `direct`). Usage example: `GET /api/v1/notifications?exclude_visibilities[]=direct&exclude_visibilities[]=private`.
	+- `with_move`: boolean, when set to `true` will include Move notifications. `false` by default.

	## 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.
	- `content_type`: string, contain the MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint.
	- `to`: A list of nicknames (like `lain@soykaf.club` or `lain` on the local server) that will be used to determine who is going to be addressed by this post. Using this will disable the implicit addressing by mentioned names in the `status` body, only the people in the `to` list will be addressed. The normal rules for for post visibility are not affected by this and will still apply.
	- `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`.
	- `expires_in`: The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour.
	- `in_reply_to_conversation_id`: Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`.

	## GET `/api/v1/statuses`

	An endpoint to get multiple statuses by IDs.

	Required parameters:

	- `ids`: array of activity ids

	Usage example: `GET /api/v1/statuses/?ids[]=1&ids[]=2`.

	Returns: array of Status.

	The maximum number of statuses is limited to 100 per request.

	## PATCH `/api/v1/update_credentials`

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

	- `no_rich_text` - if true, html tags are stripped from all statuses requested from the API
	- `hide_followers` - if true, user's followers will be hidden
	- `hide_follows` - if true, user's follows will be hidden
	- `hide_followers_count` - if true, user's follower count will be hidden
	- `hide_follows_count` - if true, user's follow count will be hidden
	- `hide_favorites` - if true, user's favorites timeline will be hidden
	- `show_role` - if true, user's role (e.g admin, moderator) will be exposed to anyone in the API
	- `default_scope` - the scope returned under `privacy` key in Source subentity
	- `pleroma_settings_store` - Opaque user settings to be saved on the backend.
	- `skip_thread_containment` - if true, skip filtering out broken threads
	- `allow_following_move` - if true, allows automatically follow moved following accounts
	- `pleroma_background_image` - sets the background image of the user.

	### Pleroma Settings Store
	Pleroma has mechanism that allows frontends to save blobs of json for each user on the backend. This can be used to save frontend-specific settings for a user that the backend does not need to know about.

	The parameter should have a form of `{frontend_name: {...}}`, with `frontend_name` identifying your type of client, e.g. `pleroma_fe`. It will overwrite everything under this property, but will not overwrite other frontend's settings.

	This information is returned in the `verify_credentials` endpoint.

	## Authentication

	*Pleroma supports refreshing tokens.

	`POST /oauth/token`
	Post here request with grant_type=refresh_token to obtain new access token. Returns an access token.

	## Account Registration
	`POST /api/v1/accounts`

	Has theses additionnal parameters (which are the same as in Pleroma-API):
	* `fullname`: optional
	* `bio`: optional
	* `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.
	diff --git a/docs/API/pleroma_api.md b/docs/API/pleroma_api.md
	index ad16d027e..7228d805b 100644
	--- a/docs/API/pleroma_api.md
	+++ b/docs/API/pleroma_api.md
	@@ -1,513 +1,514 @@
	# 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:
	```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/pleroma/disable_account`
	### Disable an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* Response: JSON. Returns `{"status": "success"}` if the account was successfully disabled, `{"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 registrations aren't public.
	* Response: JSON. Returns a user object on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```json
	{
	"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/notifications/read`
	### Mark notifications as read
	* Method `POST`
	* Authentication: required
	* Params (mutually exclusive):
	* `id`: a single notification id to read
	* `max_id`: read all notifications up to this id
	* Response: Notification entity/Array of Notification entities that were read. In case of `max_id`, only the first 80 read notifications will be returned.

	## `/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/v1/pleroma/accounts/:id/favourites`
	### Returns favorites timeline of any user
	* Method `GET`
	* Authentication: not required
	* Params:
	* `id`: the id of the account for whom to return results
	* `limit`: optional, the number of records to retrieve
	* `since_id`: optional, returns results that are more recent than the specified id
	* `max_id`: optional, returns results that are older than the specified id
	* Response: JSON, returns a list of Mastodon Status entities on success, otherwise returns `{"error": "error_msg"}`
	* Example response:
	```json
	[
	{
	"account": {
	"id": "9hptFmUF3ztxYh3Svg",
	"url": "https://pleroma.example.org/users/nick2",
	"username": "nick2",
	...
	},
	"application": {"name": "Web", "website": null},
	"bookmarked": false,
	"card": null,
	"content": "This is :moominmamma: note 0",
	"created_at": "2019-04-15T15:42:15.000Z",
	"emojis": [],
	"favourited": false,
	"favourites_count": 1,
	"id": "9hptFmVJ02khbzYJaS",
	"in_reply_to_account_id": null,
	"in_reply_to_id": null,
	"language": null,
	"media_attachments": [],
	"mentions": [],
	"muted": false,
	"pinned": false,
	"pleroma": {
	"content": {"text/plain": "This is :moominmamma: note 0"},
	"conversation_id": 13679,
	"local": true,
	"spoiler_text": {"text/plain": "2hu"}
	},
	"reblog": null,
	"reblogged": false,
	"reblogs_count": 0,
	"replies_count": 0,
	"sensitive": false,
	"spoiler_text": "2hu",
	"tags": [{"name": "2hu", "url": "/tag/2hu"}],
	"uri": "https://pleroma.example.org/objects/198ed2a1-7912-4482-b559-244a0369e984",
	"url": "https://pleroma.example.org/notice/9hptFmVJ02khbzYJaS",
	"visibility": "public"
	}
	]
	```

	## `/api/v1/pleroma/accounts/update_*`
	### Set and clear account avatar, banner, and background

	- PATCH `/api/v1/pleroma/accounts/update_avatar`: Set/clear user avatar image
	- PATCH `/api/v1/pleroma/accounts/update_banner`: Set/clear user banner image
	- PATCH `/api/v1/pleroma/accounts/update_background`: Set/clear user background image

	## `/api/v1/pleroma/accounts/confirmation_resend`
	### Resend confirmation email
	* Method `POST`
	* Params:
	* `email`: email of that needs to be verified
	* Authentication: not required
	* Response: 204 No Content

	## `/api/v1/pleroma/mascot`
	### Gets user mascot image
	* Method `GET`
	* Authentication: required

	* Response: JSON. Returns a mastodon media attachment entity.
	* Example response:
	```json
	{
	"id": "abcdefg",
	"url": "https://pleroma.example.org/media/abcdefg.png",
	"type": "image",
	"pleroma": {
	"mime_type": "image/png"
	}
	}
	```

	### Updates user mascot image
	* Method `PUT`
	* Authentication: required
	* Params:
	* `image`: Multipart image
	* Response: JSON. Returns a mastodon media attachment entity
	when successful, otherwise returns HTTP 415 `{"error": "error_msg"}`
	* Example response:
	```json
	{
	"id": "abcdefg",
	"url": "https://pleroma.example.org/media/abcdefg.png",
	"type": "image",
	"pleroma": {
	"mime_type": "image/png"
	}
	}
	```
	* Note: Behaves exactly the same as `POST /api/v1/upload`.
	Can only accept images - any attempt to upload non-image files will be met with `HTTP 415 Unsupported Media Type`.

	## `/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
	+ * `privacy_option`: BOOLEAN field. When set to true, it removes the contents of a message from the push notification.
	* Response: JSON. Returns `{"status": "success"}` if the update was successful, otherwise returns `{"error": "error_msg"}`

	## `/api/pleroma/healthcheck`
	### Healthcheck endpoint with additional system data.
	* Method `GET`
	* Authentication: not required
	* Params: none
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).
	* Example response:
	```json
	{
	"pool_size": 0, # database connection pool
	"active": 0, # active processes
	"idle": 0, # idle processes
	"memory_used": 0.00, # Memory used
	"healthy": true, # Instance state
	"job_queue_stats": {} # Job queue stats
	}
	```

	## `/api/pleroma/change_email`
	### Change account email
	* Method `POST`
	* Authentication: required
	* Params:
	* `password`: user's password
	* `email`: new email
	* Response: JSON. Returns `{"status": "success"}` if the change was successful, `{"error": "[error message]"}` otherwise
	* Note: Currently, Mastodon has no API for changing email. If they add it in future it might be incompatible with Pleroma.

	# Pleroma Conversations

	Pleroma Conversations have the same general structure that Mastodon Conversations have. The behavior differs in the following ways when using these endpoints:

	1. Pleroma Conversations never add or remove recipients, unless explicitly changed by the user.
	2. Pleroma Conversations statuses can be requested by Conversation id.
	3. Pleroma Conversations can be replied to.

	Conversations have the additional field "recipients" under the "pleroma" key. This holds a list of all the accounts that will receive a message in this conversation.

	The status posting endpoint takes an additional parameter, `in_reply_to_conversation_id`, which, when set, will set the visiblity to direct and address only the people who are the recipients of that Conversation.


	## `GET /api/v1/pleroma/conversations/:id/statuses`
	### Timeline for a given conversation
	* Method `GET`
	* Authentication: required
	* Params: Like other timelines
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).

	## `GET /api/v1/pleroma/conversations/:id`
	### The conversation with the given ID.
	* Method `GET`
	* Authentication: required
	* Params: None
	* Response: JSON, statuses (200 - healthy, 503 unhealthy).

	## `PATCH /api/v1/pleroma/conversations/:id`
	### Update a conversation. Used to change the set of recipients.
	* Method `PATCH`
	* Authentication: required
	* Params:
	* `recipients`: A list of ids of users that should receive posts to this conversation. This will replace the current list of recipients, so submit the full list. The owner of owner of the conversation will always be part of the set of recipients, though.
	* Response: JSON, statuses (200 - healthy, 503 unhealthy)

	## `GET /api/v1/pleroma/conversations/read`
	### Marks all user's conversations as read.
	* Method `POST`
	* Authentication: required
	* Params: None
	* Response: JSON, returns a list of Mastodon Conversation entities that were marked as read (200 - healthy, 503 unhealthy).

	## `GET /api/pleroma/emoji/packs`
	### Lists the custom emoji packs on the server
	* Method `GET`
	* Authentication: not required
	* Params: None
	* Response: JSON, "ok" and 200 status and the JSON hashmap of "pack name" to "pack contents"

	## `PUT /api/pleroma/emoji/packs/:name`
	### Creates an empty custom emoji pack
	* Method `PUT`
	* Authentication: required
	* Params: None
	* Response: JSON, "ok" and 200 status or 409 if the pack with that name already exists

	## `DELETE /api/pleroma/emoji/packs/:name`
	### Delete a custom emoji pack
	* Method `DELETE`
	* Authentication: required
	* Params: None
	* Response: JSON, "ok" and 200 status or 500 if there was an error deleting the pack

	## `POST /api/pleroma/emoji/packs/:name/update_file`
	### Update a file in a custom emoji pack
	* Method `POST`
	* Authentication: required
	* Params:
	* if the `action` is `add`, adds an emoji named `shortcode` to the pack `pack_name`,
	that means that the emoji file needs to be uploaded with the request
	(thus requiring it to be a multipart request) and be named `file`.
	There can also be an optional `filename` that will be the new emoji file name
	(if it's not there, the name will be taken from the uploaded file).
	* if the `action` is `update`, changes emoji shortcode
	(from `shortcode` to `new_shortcode` or moves the file (from the current filename to `new_filename`)
	* if the `action` is `remove`, removes the emoji named `shortcode` and it's associated file
	* Response: JSON, updated "files" section of the pack and 200 status, 409 if the trying to use a shortcode
	that is already taken, 400 if there was an error with the shortcode, filename or file (additional info
	in the "error" part of the response JSON)

	## `POST /api/pleroma/emoji/packs/:name/update_metadata`
	### Updates (replaces) pack metadata
	* Method `POST`
	* Authentication: required
	* Params:
	* `new_data`: new metadata to replace the old one
	* Response: JSON, updated "metadata" section of the pack and 200 status or 400 if there was a
	problem with the new metadata (the error is specified in the "error" part of the response JSON)

	## `POST /api/pleroma/emoji/packs/download_from`
	### Requests the instance to download the pack from another instance
	* Method `POST`
	* Authentication: required
	* Params:
	* `instance_address`: the address of the instance to download from
	* `pack_name`: the pack to download from that instance
	* Response: JSON, "ok" and 200 status if the pack was downloaded, or 500 if there were
	errors downloading the pack

	## `POST /api/pleroma/emoji/packs/list_from`
	### Requests the instance to list the packs from another instance
	* Method `POST`
	* Authentication: required
	* Params:
	* `instance_address`: the address of the instance to download from
	* Response: JSON with the pack list, same as if the request was made to that instance's
	list endpoint directly + 200 status

	## `GET /api/pleroma/emoji/packs/:name/download_shared`
	### Requests a local pack from the instance
	* Method `GET`
	* Authentication: not required
	* Params: None
	* Response: the archive of the pack with a 200 status code, 403 if the pack is not set as shared,
	404 if the pack does not exist

	## `GET /api/v1/pleroma/accounts/:id/scrobbles`
	### Requests a list of current and recent Listen activities for an account
	* Method `GET`
	* Authentication: not required
	* Params: None
	* Response: An array of media metadata entities.
	* Example response:
	```json
	[
	{
	"account": {...},
	"id": "1234",
	"title": "Some Title",
	"artist": "Some Artist",
	"album": "Some Album",
	"length": 180000,
	"created_at": "2019-09-28T12:40:45.000Z"
	}
	]
	```

	## `POST /api/v1/pleroma/scrobble`
	### Creates a new Listen activity for an account
	* Method `POST`
	* Authentication: required
	* Params:
	* `title`: the title of the media playing
	* `album`: the album of the media playing [optional]
	* `artist`: the artist of the media playing [optional]
	* `length`: the length of the media playing [optional]
	* Response: the newly created media metadata entity representing the Listen activity

	# Emoji Reactions

	Emoji reactions work a lot like favourites do. They make it possible to react to a post with a single emoji character.

	## `POST /api/v1/pleroma/statuses/:id/react_with_emoji`
	### React to a post with a unicode emoji
	* Method: `POST`
	* Authentication: required
	* Params: `emoji`: A single character unicode emoji
	* Response: JSON, the status.

	## `POST /api/v1/pleroma/statuses/:id/unreact_with_emoji`
	### Remove a reaction to a post with a unicode emoji
	* Method: `POST`
	* Authentication: required
	* Params: `emoji`: A single character unicode emoji
	* Response: JSON, the status.

	## `GET /api/v1/pleroma/statuses/:id/emoji_reactions_by`
	### Get an object of emoji to account mappings with accounts that reacted to the post
	* Method: `GET`
	* Authentication: optional
	* Params: None
	* Response: JSON, a map of emoji to account list mappings.
	* Example Response:
	```json
	{
	"😀" => [{"id" => "xyz.."...}, {"id" => "zyx..."}],
	"🗡" => [{"id" => "abc..."}]
	}
	```
	diff --git a/docs/administration/CLI_tasks/config.md b/docs/administration/CLI_tasks/config.md
	index ce19e2402..e9d44b9a4 100644
	--- a/docs/administration/CLI_tasks/config.md
	+++ b/docs/administration/CLI_tasks/config.md
	@@ -1,19 +1,28 @@
	# Transfering the config to/from the database

	!!! danger
	This is a Work In Progress, not usable just yet.

	-Every command should be ran with a prefix, in case of OTP releases it is `./bin/pleroma_ctl config` and in case of source installs it's
	-`mix pleroma.config`.
	+{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Transfer config from file to DB.

	-```sh
	-$PREFIX migrate_to_db
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl config migrate_to_db
	```

	+```sh tab="From Source"
	+mix pleroma.config migrate_to_db
	+```
	+
	+
	## Transfer config from DB to `config/env.exported_from_db.secret.exs`

	-```sh
	-$PREFIX migrate_from_db <env>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl config migrate_from_db <env>
	```
	+
	+```sh tab="From Source"
	+mix pleroma.config migrate_from_db <env>
	+```
	+
	diff --git a/docs/administration/CLI_tasks/database.md b/docs/administration/CLI_tasks/database.md
	index 3011646c8..51c7484ba 100644
	--- a/docs/administration/CLI_tasks/database.md
	+++ b/docs/administration/CLI_tasks/database.md
	@@ -1,51 +1,71 @@
	# Database maintenance tasks

	-Every command should be ran with a prefix, in case of OTP releases it is `./bin/pleroma_ctl database` and in case of source installs it's `mix pleroma.database`.
	+{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	!!! danger
	These mix tasks can take a long time to complete. Many of them were written to address specific database issues that happened because of bugs in migrations or other specific scenarios. Do not run these tasks "just in case" if everything is fine your instance.

	## Replace embedded objects with their references

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

	-```sh
	-$PREFIX remove_embedded_objects [<options>]
	+```sh tab="OTP"
	+./bin/pleroma_ctl database remove_embedded_objects [<options>]
	+```
	+
	+```sh tab="From Source"
	+mix pleroma.database remove_embedded_objects [<options>]
	```

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

	## Prune old remote posts from the database

	This will prune remote posts older than 90 days (configurable with [`config :pleroma, :instance, remote_post_retention_days`](../../configuration/cheatsheet.md#instance)) from the database, they will be refetched from source when accessed.

	-!!! note
	- The disk space will only be reclaimed after `VACUUM FULL`
	+!!! danger
	+ The disk space will only be reclaimed after `VACUUM FULL`. You may run out of disk space during the execution of the task or vacuuming if you don't have about 1/3rds of the database size free.
	+
	+```sh tab="OTP"
	+./bin/pleroma_ctl database prune_objects [<options>]
	+```

	-```sh
	-$PREFIX pleroma.database prune_objects [<options>]
	+```sh tab="From Source"
	+mix pleroma.database prune_objects [<options>]
	```

	### Options
	- `--vacuum` - run `VACUUM FULL` after the objects are pruned

	## Create a conversation for all existing DMs

	Can be safely re-run

	-```sh
	-$PREFIX bump_all_conversations
	+```sh tab="OTP"
	+./bin/pleroma_ctl database bump_all_conversations
	+```
	+
	+```sh tab="From Source"
	+mix pleroma.database bump_all_conversations
	```

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

	-```sh
	-$PREFIX update_users_following_followers_counts
	+```sh tab="OTP"
	+./bin/pleroma_ctl database update_users_following_followers_counts
	+```
	+
	+```sh tab="From Source"
	+mix pleroma.database update_users_following_followers_counts
	```

	## Fix the pre-existing "likes" collections for all objects

	-```sh
	-$PREFIX fix_likes_collections
	+```sh tab="OTP"
	+./bin/pleroma_ctl database fix_likes_collections
	+```
	+
	+```sh tab="From Source"
	+mix pleroma.database fix_likes_collections
	```
	diff --git a/docs/administration/CLI_tasks/digest.md b/docs/administration/CLI_tasks/digest.md
	index 547702031..a70f24c06 100644
	--- a/docs/administration/CLI_tasks/digest.md
	+++ b/docs/administration/CLI_tasks/digest.md
	@@ -1,13 +1,24 @@
	# Managing digest emails
	-Every command should be ran with a prefix, in case of OTP releases it is `./bin/pleroma_ctl digest` and in case of source installs it's `mix pleroma.digest`.
	+
	+{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Send digest email since given date (user registration date by default) ignoring user activity status.

	-```sh
	-$PREFIX test <nickname> [<since_date>]
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl digest test <nickname> [<since_date>]
	+```
	+
	+```sh tab="From Source"
	+mix pleroma.digest test <nickname> [<since_date>]
	```

	+
	Example:
	-```sh
	-$PREFIX test donaldtheduck 2019-05-20
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl digest test donaldtheduck 2019-05-20
	```
	+
	+```sh tab="From Source"
	+mix pleroma.digest test donaldtheduck 2019-05-20
	+```
	+
	diff --git a/docs/administration/CLI_tasks/emoji.md b/docs/administration/CLI_tasks/emoji.md
	index eee02f2ef..a3207bc6c 100644
	--- a/docs/administration/CLI_tasks/emoji.md
	+++ b/docs/administration/CLI_tasks/emoji.md
	@@ -1,30 +1,46 @@
	# Managing emoji packs

	-Every command should be ran with a prefix, in case of OTP releases it is `./bin/pleroma_ctl emoji` and in case of source installs it's `mix pleroma.emoji`.
	+{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Lists emoji packs and metadata specified in the manifest

	-```sh
	-$PREFIX ls-packs [<options>]
	+```sh tab="OTP"
	+./bin/pleroma_ctl emoji ls-packs [<options>]
	```

	+```sh tab="From Source"
	+mix pleroma.emoji ls-packs [<options>]
	+```
	+
	+
	### Options
	- `-m, --manifest PATH/URL` - path to a custom manifest, it can either be an URL starting with `http`, in that case the manifest will be fetched from that address, or a local path

	## Fetch, verify and install the specified packs from the manifest into `STATIC-DIR/emoji/PACK-NAME`
	-```sh
	-$PREFIX get-packs [<options>] <packs>
	+
	+```sh tab="OTP"
	+./bin/pleroma_ctl emoji get-packs [<options>] <packs>
	+```
	+
	+```sh tab="From Source"
	+mix pleroma.emoji get-packs [<options>] <packs>
	```

	### Options
	- `-m, --manifest PATH/URL` - same as [`ls-packs`](#ls-packs)

	## Create a new manifest entry and a file list from the specified remote pack file
	-```sh
	-$PREFIX gen-pack PACK-URL
	+
	+```sh tab="OTP"
	+./bin/pleroma_ctl emoji gen-pack PACK-URL
	```
	+
	+```sh tab="From Source"
	+mix pleroma.emoji gen-pack PACK-URL
	+```
	+
	Currently, only .zip archives are recognized as remote pack files and packs are therefore assumed to be zip archives. This command is intended to run interactively and will first ask you some basic questions about the pack, then download the remote file and generate an SHA256 checksum for it, then generate an emoji file list for you.

	The manifest entry will either be written to a newly created `index.json` file or appended to the existing one, replacing the old pack with the same name if it was in the file previously.

	The file list will be written to the file specified previously, replacing that file. You _should_ check that the file list doesn't contain anything you don't need in the pack, that is, anything that is not an emoji (the whole pack is downloaded, but only emoji files are extracted).
	diff --git a/docs/administration/CLI_tasks/general_cli_task_info.include b/docs/administration/CLI_tasks/general_cli_task_info.include
	new file mode 100644
	index 000000000..a1ff1da12
	--- /dev/null
	+++ b/docs/administration/CLI_tasks/general_cli_task_info.include
	@@ -0,0 +1,5 @@
	+Every command should be ran as the `pleroma` user from it's home directory. For example if you are superuser, you would have to wrap the command in `su pleroma -s $SHELL -lc "$COMMAND"`.
	+
	+??? note "From source note about `MIX_ENV`"
	+
	+ The `mix` command should be prefixed with the name of environment your Pleroma server is running in, usually it's `MIX_ENV=prod`
	diff --git a/docs/administration/CLI_tasks/instance.md b/docs/administration/CLI_tasks/instance.md
	index ab0b68ad0..1a3b268be 100644
	--- a/docs/administration/CLI_tasks/instance.md
	+++ b/docs/administration/CLI_tasks/instance.md
	@@ -1,30 +1,35 @@
	# Managing instance configuration

	-Every command should be ran with a prefix, in case of OTP releases it is `./bin/pleroma_ctl instance` and in case of source installs it's `mix pleroma.instance`.
	+{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Generate a new configuration file
	-```sh
	-$PREFIX gen [<options>]
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl instance gen [<options>]
	```

	+```sh tab="From Source"
	+mix pleroma.instance gen [<options>]
	+```
	+
	+
	If any of the options are left unspecified, you will be prompted interactively.

	### Options
	- `-f`, `--force` - overwrite any output files
	- `-o <path>`, `--output <path>` - the output file for the generated configuration
	- `--output-psql <path>` - the output file for the generated PostgreSQL setup
	- `--domain <domain>` - the domain of your instance
	- `--instance-name <instance_name>` - the name of your instance
	- `--admin-email <email>` - the email address of the instance admin
	- `--notify-email <email>` - email address for notifications
	- `--dbhost <hostname>` - the hostname of the PostgreSQL database to use
	- `--dbname <database_name>` - the name of the database to use
	- `--dbuser <username>` - the user (aka role) to use for the database connection
	- `--dbpass <password>` - the password to use for the database connection
	- `--rum <Y\|N>` - Whether to enable RUM indexes
	- `--indexable <Y\|N>` - Allow/disallow indexing site by search engines
	- `--db-configurable <Y\|N>` - Allow/disallow configuring instance from admin part
	- `--uploads-dir <path>` - the directory uploads go in when using a local uploader
	- `--static-dir <path>` - the directory custom public files should be read from (custom emojis, frontend bundle overrides, robots.txt, etc.)
	- `--listen-ip <ip>` - the ip the app should listen to, defaults to 127.0.0.1
	- `--listen-port <port>` - the port the app should listen to, defaults to 4000
	diff --git a/docs/administration/CLI_tasks/relay.md b/docs/administration/CLI_tasks/relay.md
	index aa44617df..c4f078f4d 100644
	--- a/docs/administration/CLI_tasks/relay.md
	+++ b/docs/administration/CLI_tasks/relay.md
	@@ -1,30 +1,33 @@
	# Managing relays

	-Every command should be ran with a prefix, in case of OTP releases it is `./bin/pleroma_ctl relay` and in case of source installs it's `mix pleroma.relay`.
	+{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Follow a relay
	-```sh
	-$PREFIX follow <relay_url>
	+
	+```sh tab="OTP"
	+./bin/pleroma_ctl relay follow <relay_url>
	```

	-Example:
	-```sh
	-$PREFIX follow https://example.org/relay
	+```sh tab="From Source"
	+mix pleroma.relay follow <relay_url>
	```

	## Unfollow a remote relay

	-```sh
	-$PREFIX unfollow <relay_url>
	+```sh tab="OTP"
	+./bin/pleroma_ctl relay unfollow <relay_url>
	```

	-Example:
	-```sh
	-$PREFIX unfollow https://example.org/relay
	+```sh tab="From Source"
	+mix pleroma.relay unfollow <relay_url>
	```

	## List relay subscriptions

	-```sh
	-$PREFIX list
	+```sh tab="OTP"
	+./bin/pleroma_ctl relay list
	+```
	+
	+```sh tab="From Source"
	+mix pleroma.relay list
	```
	diff --git a/docs/administration/CLI_tasks/uploads.md b/docs/administration/CLI_tasks/uploads.md
	index 71800e341..e36c94c38 100644
	--- a/docs/administration/CLI_tasks/uploads.md
	+++ b/docs/administration/CLI_tasks/uploads.md
	@@ -1,12 +1,17 @@
	# Managing uploads

	-Every command should be ran with a prefix, in case of OTP releases it is `./bin/pleroma_ctl uploads` and in case of source installs it's `mix pleroma.uploads`.
	+{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Migrate uploads from local to remote storage
	-```sh
	-$PREFIX migrate_local <target_uploader> [<options>]
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl uploads migrate_local <target_uploader> [<options>]
	```
	+
	+```sh tab="From Source"
	+mix pleroma.uploads migrate_local <target_uploader> [<options>]
	+```
	+
	### Options
	- `--delete` - delete local uploads after migrating them to the target uploader

	A list of available uploaders can be seen in [Configuration Cheat Sheet](../../configuration/cheatsheet.md#pleromaupload)
	diff --git a/docs/administration/CLI_tasks/user.md b/docs/administration/CLI_tasks/user.md
	index 96b2d9e6a..da8363131 100644
	--- a/docs/administration/CLI_tasks/user.md
	+++ b/docs/administration/CLI_tasks/user.md
	@@ -1,99 +1,180 @@
	# Managing users

	-Every command should be ran with a prefix, in case of OTP releases it is `./bin/pleroma_ctl user` and in case of source installs it's `mix pleroma.user`.
	+{! backend/administration/CLI_tasks/general_cli_task_info.include !}

	## Create a user
	-```sh
	-$PREFIX new <nickname> <email> [<options>]
	+
	+```sh tab="OTP"
	+./bin/pleroma_ctl user new <email> [<options>]
	+```
	+
	+```sh tab="From Source"
	+mix pleroma.user new <email> [<options>]
	```

	+
	### Options
	- `--name <name>` - the user's display name
	- `--bio <bio>` - the user's bio
	- `--password <password>` - the user's password
	- `--moderator`/`--no-moderator` - whether the user should be a moderator
	- `--admin`/`--no-admin` - whether the user should be an admin
	- `-y`, `--assume-yes`/`--no-assume-yes` - whether to assume yes to all questions

	## List local users
	-```sh
	-$PREFIX list
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user list
	```

	+```sh tab="From Source"
	+mix pleroma.user list
	+```
	+
	+
	## Generate an invite link
	-```sh
	-$PREFIX invite [<options>]
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user invite [<options>]
	```

	+```sh tab="From Source"
	+mix pleroma.user invite [<options>]
	+```
	+
	+
	### 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
	-```sh
	-$PREFIX invites
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user invites
	```

	+```sh tab="From Source"
	+mix pleroma.user invites
	+```
	+
	+
	## Revoke invite
	-```sh
	-$PREFIX revoke_invite <token_or_id>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user revoke_invite <token_or_id>
	```

	+```sh tab="From Source"
	+mix pleroma.user revoke_invite <token_or_id>
	+```
	+
	+
	## Delete a user
	-```sh
	-$PREFIX rm <nickname>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user rm <nickname>
	```

	+```sh tab="From Source"
	+mix pleroma.user rm <nickname>
	+```
	+
	+
	## Delete user's posts and interactions
	-```sh
	-$PREFIX delete_activities <nickname>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user delete_activities <nickname>
	```

	+```sh tab="From Source"
	+mix pleroma.user delete_activities <nickname>
	+```
	+
	+
	## Sign user out from all applications (delete user's OAuth tokens and authorizations)
	-```sh
	-$PREFIX sign_out <nickname>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user sign_out <nickname>
	```

	+```sh tab="From Source"
	+mix pleroma.user sign_out <nickname>
	+```
	+
	+
	## Deactivate or activate a user
	-```sh
	-$PREFIX toggle_activated <nickname>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user toggle_activated <nickname>
	```

	+```sh tab="From Source"
	+mix pleroma.user toggle_activated <nickname>
	+```
	+
	+
	## Unsubscribe local users from a user and deactivate the user
	-```sh
	-$PREFIX unsubscribe NICKNAME
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user unsubscribe NICKNAME
	```

	+```sh tab="From Source"
	+mix pleroma.user unsubscribe NICKNAME
	+```
	+
	+
	## Unsubscribe local users from an instance and deactivate all accounts on it
	-```sh
	-$PREFIX unsubscribe_all_from_instance <instance>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user unsubscribe_all_from_instance <instance>
	```

	+```sh tab="From Source"
	+mix pleroma.user unsubscribe_all_from_instance <instance>
	+```
	+
	+
	## Create a password reset link for user
	-```sh
	-$PREFIX reset_password <nickname>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user reset_password <nickname>
	```

	+```sh tab="From Source"
	+mix pleroma.user reset_password <nickname>
	+```
	+
	+
	## Set the value of the given user's settings
	-```sh
	-$PREFIX set <nickname> [<options>]
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user set <nickname> [<options>]
	```
	+
	+```sh tab="From Source"
	+mix pleroma.user set <nickname> [<options>]
	+```
	+
	### Options
	- `--locked`/`--no-locked` - whether the user should be locked
	- `--moderator`/`--no-moderator` - whether the user should be a moderator
	- `--admin`/`--no-admin` - whether the user should be an admin

	## Add tags to a user
	-```sh
	-$PREFIX tag <nickname> <tags>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user tag <nickname> <tags>
	```

	+```sh tab="From Source"
	+mix pleroma.user tag <nickname> <tags>
	+```
	+
	+
	## Delete tags from a user
	-```sh
	-$PREFIX untag <nickname> <tags>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user untag <nickname> <tags>
	```

	+```sh tab="From Source"
	+mix pleroma.user untag <nickname> <tags>
	+```
	+
	+
	## Toggle confirmation status of the user
	-```sh
	-$PREFIX toggle_confirmed <nickname>
	+```sh tab="OTP"
	+ ./bin/pleroma_ctl user toggle_confirmed <nickname>
	```
	+
	+```sh tab="From Source"
	+mix pleroma.user toggle_confirmed <nickname>
	+```
	+
	diff --git a/lib/mix/tasks/pleroma/notification_settings.ex b/lib/mix/tasks/pleroma/notification_settings.ex
	new file mode 100644
	index 000000000..7d65f0587
	--- /dev/null
	+++ b/lib/mix/tasks/pleroma/notification_settings.ex
	@@ -0,0 +1,83 @@
	+defmodule Mix.Tasks.Pleroma.NotificationSettings do
	+ @shortdoc "Enable&Disable privacy option for push notifications"
	+ @moduledoc """
	+ Example:
	+
	+ > mix pleroma.notification_settings --privacy-option=false --nickname-users="parallel588" # set false only for parallel588 user
	+ > mix pleroma.notification_settings --privacy-option=true # set true for all users
	+
	+ """
	+
	+ use Mix.Task
	+ import Mix.Pleroma
	+ import Ecto.Query
	+
	+ def run(args) do
	+ start_pleroma()
	+
	+ {options, _, _} =
	+ OptionParser.parse(
	+ args,
	+ strict: [
	+ privacy_option: :boolean,
	+ email_users: :string,
	+ nickname_users: :string
	+ ]
	+ )
	+
	+ privacy_option = Keyword.get(options, :privacy_option)
	+
	+ if not is_nil(privacy_option) do
	+ privacy_option
	+ \|> build_query(options)
	+ \|> Pleroma.Repo.update_all([])
	+ end
	+
	+ shell_info("Done")
	+ end
	+
	+ defp build_query(privacy_option, options) do
	+ query =
	+ from(u in Pleroma.User,
	+ update: [
	+ set: [
	+ notification_settings:
	+ fragment(
	+ "jsonb_set(notification_settings, '{privacy_option}', ?)",
	+ ^privacy_option
	+ )
	+ ]
	+ ]
	+ )
	+
	+ user_emails =
	+ options
	+ \|> Keyword.get(:email_users, "")
	+ \|> String.split(",")
	+ \|> Enum.map(&String.trim(&1))
	+ \|> Enum.reject(&(&1 == ""))
	+
	+ query =
	+ if length(user_emails) > 0 do
	+ where(query, [u], u.email in ^user_emails)
	+ else
	+ query
	+ end
	+
	+ user_nicknames =
	+ options
	+ \|> Keyword.get(:nickname_users, "")
	+ \|> String.split(",")
	+ \|> Enum.map(&String.trim(&1))
	+ \|> Enum.reject(&(&1 == ""))
	+
	+ query =
	+ if length(user_nicknames) > 0 do
	+ where(query, [u], u.nickname in ^user_nicknames)
	+ else
	+ query
	+ end
	+
	+ query
	+ end
	+end
	diff --git a/lib/mix/tasks/pleroma/user.ex b/lib/mix/tasks/pleroma/user.ex
	index bc8eacda8..0adb78fe3 100644
	--- a/lib/mix/tasks/pleroma/user.ex
	+++ b/lib/mix/tasks/pleroma/user.ex
	@@ -1,414 +1,414 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.User do
	use Mix.Task
	import Mix.Pleroma
	alias Ecto.Changeset
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.OAuth

	@shortdoc "Manages Pleroma users"
	@moduledoc File.read!("docs/administration/CLI_tasks/user.md")

	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)

	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 shell_yes?("Continue?")

	if proceed? do
	start_pleroma()

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

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

	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
	shell_info("User will not be created.")
	end
	end

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

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	User.perform(:delete, user)
	shell_info("User #{nickname} deleted.")
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

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

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

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

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

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

	IO.puts(
	"URL: #{
	Pleroma.Web.Router.Helpers.reset_password_url(
	Pleroma.Web.Endpoint,
	:reset,
	token.token
	)
	}"
	)
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

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

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

	user
	\|> User.get_friends()
	\|> Enum.each(fn friend ->
	user = User.get_cached_by_id(user.id)

	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.get_friends(user)) do
	shell_info("Successfully unsubscribed all followers from #{user.nickname}")
	end
	else
	_ ->
	shell_error("No user #{nickname}")
	end
	end

	def run(["unsubscribe_all_from_instance", instance]) do
	start_pleroma()

	Pleroma.User.Query.build(%{nickname: "@#{instance}"})
	\|> Pleroma.RepoStreamer.chunk_stream(500)
	\|> Stream.each(fn users ->
	users
	\|> Enum.each(fn user ->
	run(["unsubscribe", user.nickname])
	end)
	end)
	\|> Stream.run()
	end

	def run(["set", nickname \| rest]) do
	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
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

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

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

	shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
	else
	_ ->
	shell_error("Could not change user tags for #{nickname}")
	end
	end

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

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

	shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
	else
	_ ->
	shell_error("Could not change user tags for #{nickname}")
	end
	end

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

	start_pleroma()

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

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

	IO.puts(url)
	else
	error ->
	shell_error("Could not create invite token: #{inspect(error)}")
	end
	end

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

	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

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

	with {:ok, invite} <- UserInviteToken.find_by_token(token),
	{:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
	shell_info("Invite for token #{token} was revoked.")
	else
	_ -> shell_error("No invite found with token #{token}")
	end
	end

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

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

	def run(["toggle_confirmed", nickname]) do
	start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	{:ok, user} = User.toggle_confirmation(user)

	message = if user.confirmation_pending, do: "needs", else: "doesn't need"

	shell_info("#{nickname} #{message} confirmation.")
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

	def run(["sign_out", nickname]) do
	start_pleroma()

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	OAuth.Token.delete_user_tokens(user)
	OAuth.Authorization.delete_user_authorizations(user)

	shell_info("#{nickname} signed out from all apps.")
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

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

	Pleroma.User.Query.build(%{local: true})
	\|> Pleroma.RepoStreamer.chunk_stream(500)
	\|> Stream.each(fn users ->
	users
	\|> Enum.each(fn user ->
	shell_info(
	- "#{user.nickname} moderator: #{user.info.is_moderator}, admin: #{user.info.is_admin}, locked: #{
	- user.info.locked
	- }, deactivated: #{user.info.deactivated}"
	+ "#{user.nickname} moderator: #{user.is_moderator}, admin: #{user.is_admin}, locked: #{
	+ user.locked
	+ }, deactivated: #{user.deactivated}"
	)
	end)
	end)
	\|> Stream.run()
	end

	defp set_moderator(user, value) do
	{:ok, user} =
	user
	\|> Changeset.change(%{is_moderator: value})
	\|> User.update_and_set_cache()

	shell_info("Moderator status of #{user.nickname}: #{user.is_moderator}")
	user
	end

	defp set_admin(user, value) do
	{:ok, user} =
	user
	\|> Changeset.change(%{is_admin: value})
	\|> User.update_and_set_cache()

	shell_info("Admin status of #{user.nickname}: #{user.is_admin}")
	user
	end

	defp set_locked(user, value) do
	{:ok, user} =
	user
	\|> Changeset.change(%{locked: value})
	\|> User.update_and_set_cache()

	shell_info("Locked status of #{user.nickname}: #{user.locked}")
	user
	end
	end
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index 0f7b40840..ab7f6d502 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,175 +1,176 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Application do
	import Cachex.Spec
	use Application

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]
	@env Mix.env()

	def name, do: @name
	def version, do: @version
	def named_version, do: @name <> " " <> @version
	def repository, do: @repository

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

	custom ->
	custom
	end
	end

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

	# Define workers and child supervisors to be supervised
	children =
	[
	Pleroma.Repo,
	Pleroma.Config.TransferTask,
	Pleroma.Emoji,
	Pleroma.Captcha,
	Pleroma.Plugs.RateLimiter.Supervisor
	] ++
	cachex_children() ++
	hackney_pool_children() ++
	[
	Pleroma.Stats,
	Pleroma.JobQueueMonitor,
	{Oban, Pleroma.Config.get(Oban)}
	] ++
	task_children(@env) ++
	streamer_child(@env) ++
	chat_child(@env, chat_enabled?()) ++
	[
	Pleroma.Web.Endpoint,
	Pleroma.Gopher.Server
	]

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

	defp setup_instrumenters do
	require Prometheus.Registry

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

	Pleroma.Repo.Instrumenter.setup()
	end

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

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

	defp cachex_children do
	[
	build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
	build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
	build_cachex("scrubber", limit: 2500),
	build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500),
	build_cachex("web_resp", limit: 2500),
	build_cachex("emoji_packs", expiration: emoji_packs_expiration(), limit: 10),
	build_cachex("failed_proxy_url", limit: 2500)
	]
	end

	defp emoji_packs_expiration,
	do: expiration(default: :timer.seconds(5 * 60), interval: :timer.seconds(60))

	defp idempotency_expiration,
	do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))

	defp seconds_valid_interval,
	do: :timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))

	defp build_cachex(type, opts),
	do: %{
	id: String.to_atom("cachex_" <> type),
	start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
	type: :worker
	}

	defp chat_enabled?, do: Pleroma.Config.get([:chat, :enabled])

	defp streamer_child(:test), do: []

	defp streamer_child(_) do
	[Pleroma.Web.Streamer.supervisor()]
	end

	defp chat_child(_env, true) do
	[Pleroma.Web.ChatChannel.ChatChannelState]
	end

	defp chat_child(_, _), do: []

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

	defp task_children(:test) do
	[
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	}
	]
	end

	defp task_children(_) do
	[
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	},
	%{
	id: :internal_fetch_init,
	start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
	restart: :temporary
	}
	]
	end
	end
	diff --git a/lib/pleroma/html.ex b/lib/pleroma/html.ex
	index 71c53ce0e..2cae29f35 100644
	--- a/lib/pleroma/html.ex
	+++ b/lib/pleroma/html.ex
	@@ -1,314 +1,120 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTML do
	+ # Scrubbers are compiled on boot so they can be configured in OTP releases
	+ # @on_load :compile_scrubbers
	+
	+ def compile_scrubbers do
	+ dir = Path.join(:code.priv_dir(:pleroma), "scrubbers")
	+
	+ dir
	+ \|> File.ls!()
	+ \|> Enum.map(&Path.join(dir, &1))
	+ \|> Kernel.ParallelCompiler.compile()
	+ \|> case do
	+ {:error, _errors, _warnings} ->
	+ raise "Compiling scrubbers failed"
	+
	+ {:ok, _modules, _warnings} ->
	+ :ok
	+ end
	+ end
	+
	defp get_scrubbers(scrubber) when is_atom(scrubber), do: [scrubber]
	defp get_scrubbers(scrubbers) when is_list(scrubbers), do: scrubbers
	defp get_scrubbers(_), do: [Pleroma.HTML.Scrubber.Default]

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

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

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

	def filter_tags(html, scrubber) do
	{:ok, content} = FastSanitize.Sanitizer.scrub(html, scrubber)
	content
	end

	def filter_tags(html), do: filter_tags(html, nil)
	def strip_tags(html), do: filter_tags(html, FastSanitize.Sanitizer.StripTags)

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

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

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

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

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

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

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

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

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

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

	{:commit, {:ok, result}}
	end)
	end
	end
	-
	-defmodule Pleroma.HTML.Scrubber.TwitterText do
	- @moduledoc """
	- An HTML scrubbing policy which limits to twitter-style text. Only
	- paragraphs, breaks and links are allowed through the filter.
	- """
	-
	- @valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])
	-
	- require FastSanitize.Sanitizer.Meta
	- alias FastSanitize.Sanitizer.Meta
	-
	- Meta.strip_comments()
	-
	- # links
	- Meta.allow_tag_with_uri_attributes(:a, ["href", "data-user", "data-tag"], @valid_schemes)
	-
	- Meta.allow_tag_with_this_attribute_values(:a, "class", [
	- "hashtag",
	- "u-url",
	- "mention",
	- "u-url mention",
	- "mention u-url"
	- ])
	-
	- Meta.allow_tag_with_this_attribute_values(:a, "rel", [
	- "tag",
	- "nofollow",
	- "noopener",
	- "noreferrer"
	- ])
	-
	- Meta.allow_tag_with_these_attributes(:a, ["name", "title"])
	-
	- # paragraphs and linebreaks
	- Meta.allow_tag_with_these_attributes(:br, [])
	- Meta.allow_tag_with_these_attributes(:p, [])
	-
	- # microformats
	- Meta.allow_tag_with_this_attribute_values(:span, "class", ["h-card"])
	- Meta.allow_tag_with_these_attributes(:span, [])
	-
	- # allow inline images for custom emoji
	- if Pleroma.Config.get([:markup, :allow_inline_images]) do
	- # restrict img tags to http/https only, because of MediaProxy.
	- Meta.allow_tag_with_uri_attributes(:img, ["src"], ["http", "https"])
	-
	- Meta.allow_tag_with_these_attributes(:img, [
	- "width",
	- "height",
	- "class",
	- "title",
	- "alt"
	- ])
	- end
	-
	- Meta.strip_everything_not_covered()
	-end
	-
	-defmodule Pleroma.HTML.Scrubber.Default do
	- @doc "The default HTML scrubbing policy: no "
	-
	- require FastSanitize.Sanitizer.Meta
	- alias FastSanitize.Sanitizer.Meta
	-
	- # credo:disable-for-previous-line
	- # No idea how to fix this one…
	-
	- @valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])
	-
	- Meta.strip_comments()
	-
	- Meta.allow_tag_with_uri_attributes(:a, ["href", "data-user", "data-tag"], @valid_schemes)
	-
	- Meta.allow_tag_with_this_attribute_values(:a, "class", [
	- "hashtag",
	- "u-url",
	- "mention",
	- "u-url mention",
	- "mention u-url"
	- ])
	-
	- Meta.allow_tag_with_this_attribute_values(:a, "rel", [
	- "tag",
	- "nofollow",
	- "noopener",
	- "noreferrer",
	- "ugc"
	- ])
	-
	- Meta.allow_tag_with_these_attributes(:a, ["name", "title"])
	-
	- Meta.allow_tag_with_these_attributes(:abbr, ["title"])
	-
	- Meta.allow_tag_with_these_attributes(:b, [])
	- Meta.allow_tag_with_these_attributes(:blockquote, [])
	- Meta.allow_tag_with_these_attributes(:br, [])
	- Meta.allow_tag_with_these_attributes(:code, [])
	- Meta.allow_tag_with_these_attributes(:del, [])
	- Meta.allow_tag_with_these_attributes(:em, [])
	- Meta.allow_tag_with_these_attributes(:i, [])
	- Meta.allow_tag_with_these_attributes(:li, [])
	- Meta.allow_tag_with_these_attributes(:ol, [])
	- Meta.allow_tag_with_these_attributes(:p, [])
	- Meta.allow_tag_with_these_attributes(:pre, [])
	- Meta.allow_tag_with_these_attributes(:strong, [])
	- Meta.allow_tag_with_these_attributes(:sub, [])
	- Meta.allow_tag_with_these_attributes(:sup, [])
	- Meta.allow_tag_with_these_attributes(:u, [])
	- Meta.allow_tag_with_these_attributes(:ul, [])
	-
	- Meta.allow_tag_with_this_attribute_values(:span, "class", ["h-card"])
	- Meta.allow_tag_with_these_attributes(:span, [])
	-
	- @allow_inline_images Pleroma.Config.get([:markup, :allow_inline_images])
	-
	- if @allow_inline_images do
	- # restrict img tags to http/https only, because of MediaProxy.
	- Meta.allow_tag_with_uri_attributes(:img, ["src"], ["http", "https"])
	-
	- Meta.allow_tag_with_these_attributes(:img, [
	- "width",
	- "height",
	- "class",
	- "title",
	- "alt"
	- ])
	- end
	-
	- if Pleroma.Config.get([:markup, :allow_tables]) do
	- Meta.allow_tag_with_these_attributes(:table, [])
	- Meta.allow_tag_with_these_attributes(:tbody, [])
	- Meta.allow_tag_with_these_attributes(:td, [])
	- Meta.allow_tag_with_these_attributes(:th, [])
	- Meta.allow_tag_with_these_attributes(:thead, [])
	- Meta.allow_tag_with_these_attributes(:tr, [])
	- end
	-
	- if Pleroma.Config.get([:markup, :allow_headings]) do
	- Meta.allow_tag_with_these_attributes(:h1, [])
	- Meta.allow_tag_with_these_attributes(:h2, [])
	- Meta.allow_tag_with_these_attributes(:h3, [])
	- Meta.allow_tag_with_these_attributes(:h4, [])
	- Meta.allow_tag_with_these_attributes(:h5, [])
	- end
	-
	- if Pleroma.Config.get([:markup, :allow_fonts]) do
	- Meta.allow_tag_with_these_attributes(:font, ["face"])
	- end
	-
	- Meta.strip_everything_not_covered()
	-end
	-
	-defmodule Pleroma.HTML.Transform.MediaProxy do
	- @moduledoc "Transforms inline image URIs to use MediaProxy."
	-
	- alias Pleroma.Web.MediaProxy
	-
	- def before_scrub(html), do: html
	-
	- def scrub_attribute(:img, {"src", "http" <> target}) do
	- media_url =
	- ("http" <> target)
	- \|> MediaProxy.url()
	-
	- {"src", media_url}
	- end
	-
	- def scrub_attribute(_tag, attribute), do: attribute
	-
	- def scrub({:img, attributes, children}) do
	- attributes =
	- attributes
	- \|> Enum.map(fn attr -> scrub_attribute(:img, attr) end)
	- \|> Enum.reject(&is_nil(&1))
	-
	- {:img, attributes, children}
	- end
	-
	- def scrub({:comment, _text, _children}), do: ""
	-
	- def scrub({tag, attributes, children}), do: {tag, attributes, children}
	- def scrub({_tag, children}), do: children
	- def scrub(text), do: text
	-end
	-
	-defmodule Pleroma.HTML.Scrubber.LinksOnly do
	- @moduledoc """
	- An HTML scrubbing policy which limits to links only.
	- """
	-
	- @valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])
	-
	- require FastSanitize.Sanitizer.Meta
	- alias FastSanitize.Sanitizer.Meta
	-
	- Meta.strip_comments()
	-
	- # links
	- Meta.allow_tag_with_uri_attributes(:a, ["href"], @valid_schemes)
	-
	- Meta.allow_tag_with_this_attribute_values(:a, "rel", [
	- "tag",
	- "nofollow",
	- "noopener",
	- "noreferrer",
	- "me",
	- "ugc"
	- ])
	-
	- Meta.allow_tag_with_these_attributes(:a, ["name", "title"])
	- Meta.strip_everything_not_covered()
	-end
	diff --git a/lib/pleroma/notification.ex b/lib/pleroma/notification.ex
	index 71423ce5e..8f3e46af9 100644
	--- a/lib/pleroma/notification.ex
	+++ b/lib/pleroma/notification.ex
	@@ -1,394 +1,402 @@
	# 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.Utils
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	import Ecto.Query
	import Ecto.Changeset
	require Logger

	@type t :: %__MODULE__{}

	@include_muted_option :with_muted

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

	timestamps()
	end

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

	defp for_user_query_ap_id_opts(user, opts) do
	ap_id_relations =
	[:block] ++
	if opts[@include_muted_option], do: [], else: [:notification_mute]

	preloaded_ap_ids = User.outgoing_relations_ap_ids(user, ap_id_relations)

	exclude_blocked_opts = Map.merge(%{blocked_users_ap_ids: preloaded_ap_ids[:block]}, opts)

	exclude_notification_muted_opts =
	Map.merge(%{notification_muted_users_ap_ids: preloaded_ap_ids[:notification_mute]}, opts)

	{exclude_blocked_opts, exclude_notification_muted_opts}
	end

	def for_user_query(user, opts \\ %{}) do
	{exclude_blocked_opts, exclude_notification_muted_opts} =
	for_user_query_ap_id_opts(user, opts)

	Notification
	\|> where(user_id: ^user.id)
	\|> where(
	[n, a],
	fragment(
	"? not in (SELECT ap_id FROM users WHERE deactivated = 'true')",
	a.actor
	)
	)
	\|> 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})
	\|> exclude_notification_muted(user, exclude_notification_muted_opts)
	\|> exclude_blocked(user, exclude_blocked_opts)
	\|> exclude_visibility(opts)
	\|> exclude_move(opts)
	end

	defp exclude_blocked(query, user, opts) do
	blocked_ap_ids = opts[:blocked_users_ap_ids] \|\| User.blocked_users_ap_ids(user)

	query
	\|> where([n, a], a.actor not in ^blocked_ap_ids)
	\|> where(
	[n, a],
	fragment("substring(? from '.://([^/])')", a.actor) not in ^user.domain_blocks
	)
	end

	defp exclude_notification_muted(query, _, %{@include_muted_option => true}) do
	query
	end

	defp exclude_notification_muted(query, user, opts) do
	notification_muted_ap_ids =
	opts[:notification_muted_users_ap_ids] \|\| User.notification_muted_users_ap_ids(user)

	query
	\|> where([n, a], a.actor not in ^notification_muted_ap_ids)
	\|> join(:left, [n, a], tm in Pleroma.ThreadMute,
	on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data)
	)
	\|> where([n, a, o, tm], is_nil(tm.user_id))
	end

	defp exclude_move(query, %{with_move: true}) do
	query
	end

	defp exclude_move(query, _opts) do
	where(query, [n, a], fragment("?->>'type' != 'Move'", a.data))
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	query
	+ \|> join(:left, [n, a], mutated_activity in Pleroma.Activity,
	+ on:
	+ fragment("?->>'context'", a.data) ==
	+ fragment("?->>'context'", mutated_activity.data) and
	+ fragment("(?->>'type' = 'Like' or ?->>'type' = 'Announce')", a.data, a.data) and
	+ fragment("?->>'type'", mutated_activity.data) == "Create",
	+ as: :mutated_activity
	+ )
	\|> where(
	- [n, a],
	+ [n, a, mutated_activity: mutated_activity],
	not fragment(
	- "activity_visibility(?, ?, ?) = ANY (?)",
	+ """
	+ CASE WHEN (?->>'type') = 'Like' or (?->>'type') = 'Announce'
	+ THEN (activity_visibility(?, ?, ?) = ANY (?))
	+ ELSE (activity_visibility(?, ?, ?) = ANY (?)) END
	+ """,
	+ a.data,
	+ a.data,
	+ mutated_activity.actor,
	+ mutated_activity.recipients,
	+ mutated_activity.data,
	+ ^visibility,
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)
	else
	Logger.error("Could not exclude visibility to #{visibility}")
	query
	end
	end

	defp exclude_visibility(query, %{exclude_visibilities: visibility})
	when visibility in @valid_visibilities do
	- query
	- \|> where(
	- [n, a],
	- not fragment(
	- "activity_visibility(?, ?, ?) = (?)",
	- a.actor,
	- a.recipients,
	- a.data,
	- ^visibility
	- )
	- )
	+ exclude_visibility(query, [visibility])
	end

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

	defp exclude_visibility(query, _visibility), do: query

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

	@doc """
	Returns notifications for user received since given date.

	## Examples

	iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-13 11:22:33])
	[%Pleroma.Notification{}, %Pleroma.Notification{}]

	iex> Pleroma.Notification.for_user_since(%Pleroma.User{}, ~N[2019-04-15 11:22:33])
	[]
	"""
	@spec for_user_since(Pleroma.User.t(), NaiveDateTime.t()) :: [t()]
	def for_user_since(user, date) do
	from(n in for_user_query(user),
	where: n.updated_at > ^date
	)
	\|> Repo.all()
	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,
	where: n.seen == false,
	update: [
	set: [
	seen: true,
	updated_at: ^NaiveDateTime.utc_now()
	]
	],
	# Ideally we would preload object and activities here
	# but Ecto does not support preloads in update_all
	select: n.id
	)

	{_, notification_ids} = Repo.update_all(query, [])

	Notification
	\|> where([n], n.id in ^notification_ids)
	\|> 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})
	\|> Repo.all()
	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 destroy_multiple(%{id: user_id} = _user, ids) do
	from(n in Notification,
	where: n.id in ^ids,
	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" => "Create"}} = activity) do
	object = Object.normalize(activity)

	unless object && object.data["type"] == "Answer" do
	users = get_notified_from_activity(activity)
	notifications = Enum.map(users, fn user -> create_notification(activity, user) end)
	{:ok, notifications}
	else
	{:ok, []}
	end
	end

	def create_notifications(%Activity{data: %{"type" => type}} = activity)
	when type in ["Like", "Announce", "Follow", "Move"] do
	notifications =
	activity
	\|> get_notified_from_activity()
	\|> Enum.map(&create_notification(activity, &1))

	{:ok, notifications}
	end

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

	# TODO move to sql, too.
	def create_notification(%Activity{} = activity, %User{} = user) do
	unless skip?(activity, user) do
	notification = %Notification{user_id: user.id, activity: activity}
	{:ok, notification} = Repo.insert(notification)

	["user", "user:notification"]
	\|> Streamer.stream(notification)

	Push.send(notification)
	notification
	end
	end

	def get_notified_from_activity(activity, local_only \\ true)

	def get_notified_from_activity(%Activity{data: %{"type" => type}} = activity, local_only)
	when type in ["Create", "Like", "Announce", "Follow", "Move"] do
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	\|> Utils.maybe_notify_subscribers(activity)
	\|> Utils.maybe_notify_followers(activity)
	\|> Enum.uniq()
	\|> User.get_users_from_set(local_only)
	end

	def get_notified_from_activity(_, _local_only), do: []

	@spec skip?(Activity.t(), User.t()) :: boolean()
	def skip?(activity, user) do
	[
	:self,
	:followers,
	:follows,
	:non_followers,
	:non_follows,
	:recently_followed
	]
	\|> Enum.any?(&skip?(&1, activity, user))
	end

	@spec skip?(atom(), Activity.t(), User.t()) :: boolean()
	def skip?(:self, activity, user) do
	activity.data["actor"] == user.ap_id
	end

	def skip?(
	:followers,
	activity,
	- %{notification_settings: %{"followers" => false}} = user
	+ %{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?(
	:non_followers,
	activity,
	- %{notification_settings: %{"non_followers" => false}} = user
	+ %{notification_settings: %{non_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, %{notification_settings: %{"follows" => false}} = user) do
	+ def skip?(:follows, activity, %{notification_settings: %{follows: false}} = user) do
	actor = activity.data["actor"]
	followed = User.get_cached_by_ap_id(actor)
	User.following?(user, followed)
	end

	def skip?(
	:non_follows,
	activity,
	- %{notification_settings: %{"non_follows" => false}} = user
	+ %{notification_settings: %{non_follows: false}} = user
	) do
	actor = activity.data["actor"]
	followed = User.get_cached_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/plugs/parsers_plug.ex b/lib/pleroma/plugs/parsers_plug.ex
	new file mode 100644
	index 000000000..2e493ce0e
	--- /dev/null
	+++ b/lib/pleroma/plugs/parsers_plug.ex
	@@ -0,0 +1,21 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Plugs.Parsers do
	+ @moduledoc "Initializes Plug.Parsers with upload limit set at boot time"
	+
	+ @behaviour Plug
	+
	+ def init(_opts) do
	+ Plug.Parsers.init(
	+ parsers: [:urlencoded, :multipart, :json],
	+ pass: ["/"],
	+ json_decoder: Jason,
	+ length: Pleroma.Config.get([:instance, :upload_limit]),
	+ body_reader: {Pleroma.Web.Plugs.DigestPlug, :read_body, []}
	+ )
	+ end
	+
	+ defdelegate call(conn, opts), to: Plug.Parsers
	+end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index b7f50e5ac..e2afc6de8 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1987 +1,1973 @@
	# 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
	import Ecto, only: [assoc: 2]

	alias Comeonin.Pbkdf2
	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Delivery
	alias Pleroma.FollowingRelationship
	alias Pleroma.Keys
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.RepoStreamer
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.RelMe
	alias Pleroma.Workers.BackgroundWorker

	require Logger

	@type t :: %__MODULE__{}

	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/

	@strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
	@extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/

	# AP ID user relationships (blocks, mutes etc.)
	# Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
	@user_relationships_config [
	block: [
	blocker_blocks: :blocked_users,
	blockee_blocks: :blocker_users
	],
	mute: [
	muter_mutes: :muted_users,
	mutee_mutes: :muter_users
	],
	reblog_mute: [
	reblog_muter_mutes: :reblog_muted_users,
	reblog_mutee_mutes: :reblog_muter_users
	],
	notification_mute: [
	notification_muter_mutes: :notification_muted_users,
	notification_mutee_mutes: :notification_muter_users
	],
	# Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
	inverse_subscription: [
	subscribee_subscriptions: :subscriber_users,
	subscriber_subscriptions: :subscribee_users
	]
	]

	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(:keys, :string)
	field(:ap_id, :string)
	field(:avatar, :map)
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	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(:following_count, :integer, default: 0)
	field(:locked, :boolean, default: false)
	field(:confirmation_pending, :boolean, default: false)
	field(:password_reset_pending, :boolean, default: false)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:domain_blocks, {: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(:settings, :map, default: nil)
	field(:magic_key, :string, default: nil)
	field(:uri, :string, default: nil)
	field(:hide_followers_count, :boolean, default: false)
	field(:hide_follows_count, :boolean, default: false)
	field(:hide_followers, :boolean, default: false)
	field(:hide_follows, :boolean, default: false)
	field(:hide_favorites, :boolean, default: true)
	field(:unread_conversation_count, :integer, default: 0)
	field(:pinned_activities, {:array, :string}, default: [])
	field(:email_notifications, :map, default: %{"digest" => false})
	field(:mascot, :map, default: nil)
	field(:emoji, {:array, :map}, default: [])
	field(:pleroma_settings_store, :map, default: %{})
	field(:fields, {:array, :map}, default: [])
	field(:raw_fields, {:array, :map}, default: [])
	field(:discoverable, :boolean, default: false)
	field(:invisible, :boolean, default: false)
	field(:allow_following_move, :boolean, default: true)
	field(:skip_thread_containment, :boolean, default: false)
	field(:also_known_as, {:array, :string}, default: [])

	- field(:notification_settings, :map,
	- default: %{
	- "followers" => true,
	- "follows" => true,
	- "non_follows" => true,
	- "non_followers" => true
	- }
	+ embeds_one(
	+ :notification_settings,
	+ Pleroma.User.NotificationSetting,
	+ on_replace: :update
	)

	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	has_many(:deliveries, Delivery)

	has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
	has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)

	for {relationship_type,
	[
	{outgoing_relation, outgoing_relation_target},
	{incoming_relation, incoming_relation_source}
	]} <- @user_relationships_config do
	# Definitions of `has_many :blocker_blocks`, `has_many :muter_mutes` etc.
	has_many(outgoing_relation, UserRelationship,
	foreign_key: :source_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many :blockee_blocks`, `has_many :mutee_mutes` etc.
	has_many(incoming_relation, UserRelationship,
	foreign_key: :target_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many :blocked_users`, `has_many :muted_users` etc.
	has_many(outgoing_relation_target, through: [outgoing_relation, :target])

	# Definitions of `has_many :blocker_users`, `has_many :muter_users` etc.
	has_many(incoming_relation_source, through: [incoming_relation, :source])
	end

	# `:blocks` is deprecated (replaced with `blocked_users` relation)
	field(:blocks, {:array, :string}, default: [])
	# `:mutes` is deprecated (replaced with `muted_users` relation)
	field(:mutes, {:array, :string}, default: [])
	# `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
	field(:muted_reblogs, {:array, :string}, default: [])
	# `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
	field(:muted_notifications, {:array, :string}, default: [])
	# `:subscribers` is deprecated (replaced with `subscriber_users` relation)
	field(:subscribers, {:array, :string}, default: [])

	timestamps()
	end

	for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
	@user_relationships_config do
	# Definitions of `blocked_users_relation/1`, `muted_users_relation/1`, etc.
	def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
	target_users_query = assoc(user, unquote(outgoing_relation_target))

	if restrict_deactivated? do
	restrict_deactivated(target_users_query)
	else
	target_users_query
	end
	end

	# Definitions of `blocked_users/1`, `muted_users/1`, etc.
	def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> Repo.all()
	end

	# Definitions of `blocked_users_ap_ids/1`, `muted_users_ap_ids/1`, etc.
	def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end
	end

	@doc "Returns if the user should be allowed to authenticate"
	def auth_active?(%User{deactivated: true}), do: false

	def auth_active?(%User{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{invisible: true}, _), do: false

	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, is_admin: true}), do: true
	def superuser?(%User{local: true, is_moderator: true}), do: true
	def superuser?(_), do: false

	def invisible?(%User{invisible: true}), do: true
	def invisible?(_), do: false

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

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

	def profile_url(%User{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}"

	def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
	def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"

	@spec ap_following(User.t()) :: Sring.t()
	def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
	def ap_following(%User{} = user), do: "#{ap_id(user)}/following"

	def follow_state(%User{} = user, %User{} = target) do
	case Utils.fetch_latest_follow(user, target) do
	%{data: %{"state" => state}} -> state
	# Ideally this would be nil, but then Cachex does not commit the value
	_ -> false
	end
	end

	def get_cached_follow_state(user, target) do
	key = "follow_state:#{user.ap_id}\|#{target.ap_id}"
	Cachex.fetch!(:user_cache, key, fn _ -> {:commit, follow_state(user, target)} end)
	end

	@spec set_follow_state_cache(String.t(), String.t(), String.t()) :: {:ok \| :error, boolean()}
	def set_follow_state_cache(user_ap_id, target_ap_id, state) do
	Cachex.put(:user_cache, "follow_state:#{user_ap_id}\|#{target_ap_id}", state)
	end

	@spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
	def restrict_deactivated(query) do
	from(u in query, where: u.deactivated != ^true)
	end

	defdelegate following_count(user), to: FollowingRelationship

	defp truncate_fields_param(params) do
	if Map.has_key?(params, :fields) do
	Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
	else
	params
	end
	end

	defp truncate_if_exists(params, key, max_length) do
	if Map.has_key?(params, key) and is_binary(params[key]) do
	{value, _chopped} = String.split_at(params[key], max_length)
	Map.put(params, key, value)
	else
	params
	end
	end

	def remote_user_creation(params) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	params =
	params
	\|> truncate_if_exists(:name, name_limit)
	\|> truncate_if_exists(:bio, bio_limit)
	\|> truncate_fields_param()

	changeset =
	%User{local: false}
	\|> cast(
	params,
	[
	:bio,
	:name,
	:ap_id,
	:nickname,
	:avatar,
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key,
	:uri,
	:hide_followers,
	:hide_follows,
	:hide_followers_count,
	:hide_follows_count,
	:follower_count,
	:fields,
	:following_count,
	:discoverable,
	:invisible,
	:also_known_as
	]
	)
	\|> validate_required([:name, :ap_id])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> validate_fields(true)

	case params[:source_data] do
	%{"followers" => followers, "following" => following} ->
	changeset
	\|> put_change(:follower_address, followers)
	\|> put_change(:following_address, following)

	_ ->
	followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
	put_change(changeset, :follower_address, followers)
	end
	end

	def update_changeset(struct, params \\ %{}) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	struct
	\|> cast(
	params,
	[
	:bio,
	:name,
	:avatar,
	:locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:hide_followers_count,
	:hide_follows_count,
	:hide_favorites,
	:allow_following_move,
	:background,
	:show_role,
	:skip_thread_containment,
	:fields,
	:raw_fields,
	:pleroma_settings_store,
	:discoverable,
	:also_known_as
	]
	)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_fields(false)
	end

	def upgrade_changeset(struct, params \\ %{}, remote? \\ false) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	params = Map.put(params, :last_refreshed_at, NaiveDateTime.utc_now())

	params = if remote?, do: truncate_fields_param(params), else: params

	struct
	\|> cast(
	params,
	[
	:bio,
	:name,
	:follower_address,
	:following_address,
	:avatar,
	:last_refreshed_at,
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key,
	:follower_count,
	:following_count,
	:hide_follows,
	:fields,
	:hide_followers,
	:allow_following_move,
	:discoverable,
	:hide_followers_count,
	:hide_follows_count,
	:also_known_as
	]
	)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> validate_fields(remote?)
	end

	def password_update_changeset(struct, params) do
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> put_password_hash()
	\|> put_change(:password_reset_pending, false)
	end

	@spec reset_password(User.t(), map) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def reset_password(%User{id: user_id} = user, data) do
	multi =
	Multi.new()
	\|> Multi.update(:user, password_update_changeset(user, data))
	\|> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
	\|> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))

	case Repo.transaction(multi) do
	{:ok, %{user: user} = _} -> set_cache(user)
	{:error, _, changeset, _} -> {:error, changeset}
	end
	end

	def update_password_reset_pending(user, value) do
	user
	\|> change()
	\|> put_change(:password_reset_pending, value)
	\|> update_and_set_cache()
	end

	def force_password_reset_async(user) do
	BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
	end

	@spec force_password_reset(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def force_password_reset(user), do: update_password_reset_pending(user, true)

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	need_confirmation? =
	if is_nil(opts[:need_confirmation]) do
	Pleroma.Config.get([:instance, :account_activation_required])
	else
	opts[:need_confirmation]
	end

	struct
	\|> confirmation_changeset(need_confirmation: need_confirmation?)
	\|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_format(:email, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> maybe_validate_required_email(opts[:external])
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_address()
	end

	def maybe_validate_required_email(changeset, true), do: changeset
	def maybe_validate_required_email(changeset, _), do: validate_required(changeset, [:email])

	defp put_ap_id(changeset) do
	ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
	put_change(changeset, :ap_id, ap_id)
	end

	defp put_following_and_follower_address(changeset) do
	followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})

	changeset
	\|> put_change(:follower_address, followers)
	end

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

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

	follow_all(user, autofollowed_users)
	end

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

	def post_register_action(%User{} = user) do
	with {:ok, user} <- autofollow_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
	{:ok, _} <- try_send_confirmation_email(user) do
	{:ok, user}
	end
	end

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

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

	def try_send_confirmation_email(users) do
	Enum.each(users, &try_send_confirmation_email/1)
	end

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

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

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

	def needs_update?(_), do: true

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

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

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

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

	set_cache(follower)
	end

	defdelegate following(user), to: FollowingRelationship

	def follow(%User{} = follower, %User{} = followed, state \\ "accept") do
	deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])

	cond do
	followed.deactivated ->
	{:error, "Could not follow user: #{followed.nickname} is deactivated."}

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

	true ->
	FollowingRelationship.follow(follower, followed, state)

	{:ok, _} = update_follower_count(followed)

	follower
	\|> update_following_count()
	\|> set_cache()
	end
	end

	def unfollow(%User{} = follower, %User{} = followed) do
	if following?(follower, followed) and follower.ap_id != followed.ap_id do
	FollowingRelationship.unfollow(follower, followed)

	{:ok, followed} = update_follower_count(followed)

	{:ok, follower} =
	follower
	\|> update_following_count()
	\|> set_cache()

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

	defdelegate following?(follower, followed), to: FollowingRelationship

	def locked?(%User{} = user) do
	user.locked \|\| false
	end

	def get_by_id(id) do
	Repo.get_by(User, id: id)
	end

	def get_by_ap_id(ap_id) do
	Repo.get_by(User, ap_id: ap_id)
	end

	def get_all_by_ap_id(ap_ids) do
	from(u in __MODULE__,
	where: u.ap_id in ^ap_ids
	)
	\|> Repo.all()
	end

	def get_all_by_ids(ids) do
	from(u in __MODULE__, where: u.id in ^ids)
	\|> Repo.all()
	end

	# This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
	# of the ap_id and the domain and tries to get that user
	def get_by_guessed_nickname(ap_id) do
	domain = URI.parse(ap_id).host
	name = List.last(String.split(ap_id, "/"))
	nickname = "#{name}@#{domain}"

	get_cached_by_nickname(nickname)
	end

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

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

	def update_and_set_cache(struct, params) do
	struct
	\|> update_changeset(params)
	\|> update_and_set_cache()
	end

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

	def invalidate_cache(user) do
	Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	Cachex.del(:user_cache, "nickname:#{user.nickname}")
	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 ->
	case get_or_fetch_by_nickname(nickname) do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
	restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])

	cond do
	is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)

	restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
	get_cached_by_nickname(nickname_or_id)

	restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
	get_cached_by_nickname(nickname_or_id)

	true ->
	nil
	end
	end

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

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

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

	def fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	{:ok, user}
	else
	_e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- fetch_by_nickname(nickname) do
	if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do
	fetch_initial_posts(user)
	end

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

	@doc "Fetch some posts when the user has just been federated with"
	def fetch_initial_posts(user) do
	BackgroundWorker.enqueue("fetch_initial_posts", %{"user_id" => user.id})
	end

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

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

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

	@spec get_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
	def get_followers(user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> Repo.all()
	end

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

	def get_followers_ids(user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

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

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

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

	def get_friends(user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

	def get_friends_ids(user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	defdelegate get_follow_requests(user), to: FollowingRelationship

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], inc: [note_count: 1])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def decrease_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	note_count: fragment("greatest(0, note_count - 1)")
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

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

	user
	\|> cast(%{note_count: note_count}, [:note_count])
	\|> update_and_set_cache()
	end

	@spec maybe_fetch_follow_information(User.t()) :: User.t()
	def maybe_fetch_follow_information(user) do
	with {:ok, user} <- fetch_follow_information(user) do
	user
	else
	e ->
	Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	user
	\|> follow_information_changeset(info)
	\|> update_and_set_cache()
	end
	end

	defp follow_information_changeset(user, params) do
	user
	\|> cast(params, [
	:hide_followers,
	:hide_follows,
	:follower_count,
	:following_count,
	:hide_followers_count,
	:hide_follows_count
	])
	end

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

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

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

	def update_following_count(%User{local: true} = user) do
	following_count = FollowingRelationship.following_count(user)

	user
	\|> follow_information_changeset(%{following_count: following_count})
	\|> Repo.update!()
	end

	def set_unread_conversation_count(%User{local: true} = user) do
	unread_query = Participation.unread_conversation_count_for_user(user)

	User
	\|> join(:inner, [u], p in subquery(unread_query))
	\|> update([u, p],
	set: [unread_conversation_count: p.count]
	)
	\|> where([u], u.id == ^user.id)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def set_unread_conversation_count(user), do: {:ok, user}

	def increment_unread_conversation_count(conversation, %User{local: true} = user) do
	unread_query =
	Participation.unread_conversation_count_for_user(user)
	\|> where([p], p.conversation_id == ^conversation.id)

	User
	\|> join(:inner, [u], p in subquery(unread_query))
	\|> update([u, p],
	inc: [unread_conversation_count: 1]
	)
	\|> where([u], u.id == ^user.id)
	\|> where([u, p], p.count == 0)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def increment_unread_conversation_count(_, user), do: {:ok, user}

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

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

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

	@spec mute(User.t(), User.t(), boolean()) ::
	{:ok, list(UserRelationship.t())} \| {:error, String.t()}
	def mute(%User{} = muter, %User{} = mutee, notifications? \\ true) do
	add_to_mutes(muter, mutee, notifications?)
	end

	def unmute(%User{} = muter, %User{} = mutee) do
	remove_from_mutes(muter, mutee)
	end

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

	if blocks?(target, subscriber) and deny_follow_blocked do
	{:error, "Could not subscribe: #{target.nickname} is blocking you"}
	else
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.create_inverse_subscription(target, subscriber)
	end
	end

	def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
	with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
	subscribe(subscriber, subscribee)
	end
	end

	def unsubscribe(%User{} = unsubscriber, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.delete_inverse_subscription(target, unsubscriber)
	end

	def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unsubscribe(unsubscriber, user)
	end
	end

	def block(%User{} = blocker, %User{} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

	# clear any requested follows as well
	blocked =
	case CommonAPI.reject_follow_request(blocked, blocker) do
	{:ok, %User{} = updated_blocked} -> updated_blocked
	nil -> blocked
	end

	unsubscribe(blocked, blocker)

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

	{:ok, blocker} = update_follower_count(blocker)
	{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
	add_to_block(blocker, blocked)
	end

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

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

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

	def mutes?(nil, _), do: false
	def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)

	def mutes_user?(%User{} = user, %User{} = target) do
	UserRelationship.mute_exists?(user, target)
	end

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

	def muted_notifications?(%User{} = user, %User{} = target),
	do: UserRelationship.notification_mute_exists?(user, target)

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

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

	def blocks_user?(%User{} = user, %User{} = target) do
	UserRelationship.block_exists?(user, target)
	end

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

	def blocks_domain?(%User{} = user, %User{} = target) do
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.domain_blocks)
	%{host: host} = URI.parse(target.ap_id)
	Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
	end

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

	def subscribed_to?(%User{} = user, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.inverse_subscription_exists?(target, user)
	end

	def subscribed_to?(%User{} = user, %{ap_id: ap_id}) do
	with %User{} = target <- get_cached_by_ap_id(ap_id) do
	subscribed_to?(user, target)
	end
	end

	@doc """
	Returns map of outgoing (blocked, muted etc.) relations' user AP IDs by relation type.
	E.g. `outgoing_relations_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
	"""
	@spec outgoing_relations_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
	def outgoing_relations_ap_ids(_, []), do: %{}

	def outgoing_relations_ap_ids(%User{} = user, relationship_types)
	when is_list(relationship_types) do
	db_result =
	user
	\|> assoc(:outgoing_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :target))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
	\|> group_by([user_rel, u], user_rel.relationship_type)
	\|> Repo.all()
	\|> Enum.into(%{}, fn [k, v] -> {k, v} end)

	Enum.into(
	relationship_types,
	%{},
	fn rel_type -> {rel_type, db_result[rel_type] \|\| []} end
	)
	end

	def deactivate_async(user, status \\ true) do
	BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
	end

	def deactivate(user, status \\ true)

	def deactivate(users, status) when is_list(users) do
	Repo.transaction(fn ->
	for user <- users, do: deactivate(user, status)
	end)
	end

	def deactivate(%User{} = user, status) do
	with {:ok, user} <- set_activation_status(user, status) do
	user
	\|> get_followers()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(fn follower ->
	follower \|> update_following_count() \|> set_cache()
	end)

	# Only update local user counts, remote will be update during the next pull.
	user
	\|> get_friends()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&update_follower_count/1)

	{:ok, user}
	end
	end

	def update_notification_settings(%User{} = user, settings) do
	- settings =
	- settings
	- \|> Enum.map(fn {k, v} -> {k, v in [true, "true", "True", "1"]} end)
	- \|> Map.new()
	-
	- notification_settings =
	- user.notification_settings
	- \|> Map.merge(settings)
	- \|> Map.take(["followers", "follows", "non_follows", "non_followers"])
	-
	- params = %{notification_settings: notification_settings}
	-
	user
	- \|> cast(params, [:notification_settings])
	+ \|> cast(%{notification_settings: settings}, [])
	+ \|> cast_embed(:notification_settings)
	\|> validate_required([:notification_settings])
	\|> update_and_set_cache()
	end

	def delete(users) when is_list(users) do
	for user <- users, do: delete(user)
	end

	def delete(%User{} = user) do
	BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
	end

	def perform(:force_password_reset, user), do: force_password_reset(user)

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

	# Remove all relationships
	user
	\|> get_followers()
	\|> Enum.each(fn follower ->
	ActivityPub.unfollow(follower, user)
	unfollow(follower, user)
	end)

	user
	\|> get_friends()
	\|> Enum.each(fn followed ->
	ActivityPub.unfollow(user, followed)
	unfollow(user, followed)
	end)

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

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

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

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

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

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

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

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

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

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

	Repo.all(query)
	end

	def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
	BackgroundWorker.enqueue("blocks_import", %{
	"blocker_id" => blocker.id,
	"blocked_identifiers" => blocked_identifiers
	})
	end

	def follow_import(%User{} = follower, followed_identifiers)
	when is_list(followed_identifiers) do
	BackgroundWorker.enqueue("follow_import", %{
	"follower_id" => follower.id,
	"followed_identifiers" => followed_identifiers
	})
	end

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

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

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

	activity.actor
	\|> get_cached_by_ap_id()
	\|> ActivityPub.unlike(object)
	end

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

	activity.actor
	\|> get_cached_by_ap_id()
	\|> ActivityPub.unannounce(object)
	end

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

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

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

	def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)

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

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

	resp = fetch_by_ap_id(ap_id)

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

	resp
	end
	end

	@doc """
	Creates an internal service actor by URI if missing.
	Optionally takes nickname for addressing.
	"""
	def get_or_create_service_actor_by_ap_id(uri, nickname \\ nil) do
	with user when is_nil(user) <- get_cached_by_ap_id(uri) do
	{:ok, user} =
	%User{
	invisible: true,
	local: true,
	ap_id: uri,
	nickname: nickname,
	follower_address: uri <> "/followers"
	}
	\|> Repo.insert()

	user
	end
	end

	# AP style
	def public_key(%{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

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

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

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

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

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

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

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

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

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

	def parse_bio(_), do: ""

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

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

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

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

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

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

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

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

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

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

	updated_user
	end

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

	defp local_nickname_regex do
	if 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,
	nickname: "erroruser@example.com",
	inserted_at: NaiveDateTime.utc_now()
	}
	end

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

	def showing_reblogs?(%User{} = user, %User{} = target) do
	not UserRelationship.reblog_mute_exists?(user, target)
	end

	@doc """
	The function returns a query to get users with no activity for given interval of days.
	Inactive users are those who didn't read any notification, or had any activity where
	the user is the activity's actor, during `inactivity_threshold` days.
	Deactivated users will not appear in this list.

	## Examples

	iex> Pleroma.User.list_inactive_users()
	%Ecto.Query{}
	"""
	@spec list_inactive_users_query(integer()) :: Ecto.Query.t()
	def list_inactive_users_query(inactivity_threshold \\ 7) do
	negative_inactivity_threshold = -inactivity_threshold
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	# Subqueries are not supported in `where` clauses, join gets too complicated.
	has_read_notifications =
	from(n in Pleroma.Notification,
	where: n.seen == true,
	group_by: n.id,
	having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
	select: n.user_id
	)
	\|> Pleroma.Repo.all()

	from(u in Pleroma.User,
	left_join: a in Pleroma.Activity,
	on: u.ap_id == a.actor,
	where: not is_nil(u.nickname),
	where: u.deactivated != ^true,
	where: u.id not in ^has_read_notifications,
	group_by: u.id,
	having:
	max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
	is_nil(max(a.inserted_at))
	)
	end

	@doc """
	Enable or disable email notifications for user

	## Examples

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => false}}, "digest", true)
	Pleroma.User{email_notifications: %{"digest" => true}}

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{email_notifications: %{"digest" => true}}, "digest", false)
	Pleroma.User{email_notifications: %{"digest" => false}}
	"""
	@spec switch_email_notifications(t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, Ecto.Changeset.t()}
	def switch_email_notifications(user, type, status) do
	User.update_email_notifications(user, %{type => status})
	end

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

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

	updated_user
	end

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

	@spec toggle_confirmation([User.t()]) :: [{:ok, User.t()} \| {:error, Changeset.t()}]
	def toggle_confirmation(users) do
	Enum.map(users, &toggle_confirmation/1)
	end

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

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

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

	def ensure_keys_present(%{keys: keys} = user) when not is_nil(keys), do: {:ok, user}

	def ensure_keys_present(%User{} = user) do
	with {:ok, pem} <- Keys.generate_rsa_pem() do
	user
	\|> cast(%{keys: pem}, [:keys])
	\|> validate_required([:keys])
	\|> update_and_set_cache()
	end
	end

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

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

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

	defp put_password_hash(changeset), do: changeset

	def is_internal_user?(%User{nickname: nil}), do: true
	def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
	def is_internal_user?(_), do: false

	# A hack because user delete activities have a fake id for whatever reason
	# TODO: Get rid of this
	def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []

	def get_delivered_users_by_object_id(object_id) do
	from(u in User,
	inner_join: delivery in assoc(u, :deliveries),
	where: delivery.object_id == ^object_id
	)
	\|> Repo.all()
	end

	def change_email(user, email) do
	user
	\|> cast(%{email: email}, [:email])
	\|> validate_required([:email])
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> update_and_set_cache()
	end

	# Internal function; public one is `deactivate/2`
	defp set_activation_status(user, deactivated) do
	user
	\|> cast(%{deactivated: deactivated}, [:deactivated])
	\|> update_and_set_cache()
	end

	def update_banner(user, banner) do
	user
	\|> cast(%{banner: banner}, [:banner])
	\|> update_and_set_cache()
	end

	def update_background(user, background) do
	user
	\|> cast(%{background: background}, [:background])
	\|> update_and_set_cache()
	end

	def update_source_data(user, source_data) do
	user
	\|> cast(%{source_data: source_data}, [:source_data])
	\|> update_and_set_cache()
	end

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

	# ``fields`` is an array of mastodon profile field, containing ``{"name": "…", "value": "…"}``.
	# For example: [{"name": "Pronoun", "value": "she/her"}, …]
	def fields(%{fields: nil, source_data: %{"attachment" => attachment}}) do
	limit = Pleroma.Config.get([:instance, :max_remote_account_fields], 0)

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

	def fields(%{fields: nil}), do: []

	def fields(%{fields: fields}), do: fields

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

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

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

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

	defp valid_field?(_), do: false

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

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

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

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

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

	def mastodon_settings_update(user, settings) do
	user
	\|> cast(%{settings: settings}, [:settings])
	\|> validate_required([:settings])
	\|> update_and_set_cache()
	end

	@spec confirmation_changeset(User.t(), keyword()) :: Changeset.t()
	def confirmation_changeset(user, need_confirmation: need_confirmation?) do
	params =
	if need_confirmation? do
	%{
	confirmation_pending: true,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	}
	else
	%{
	confirmation_pending: false,
	confirmation_token: nil
	}
	end

	cast(user, params, [:confirmation_pending, :confirmation_token])
	end

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

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

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

	user
	\|> cast(params, [:pinned_activities])
	\|> update_and_set_cache()
	end

	def update_email_notifications(user, settings) do
	email_notifications =
	user.email_notifications
	\|> Map.merge(settings)
	\|> Map.take(["digest"])

	params = %{email_notifications: email_notifications}
	fields = [:email_notifications]

	user
	\|> cast(params, fields)
	\|> validate_required(fields)
	\|> update_and_set_cache()
	end

	defp set_domain_blocks(user, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

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

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

	def unblock_domain(user, domain_blocked) do
	set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:error, Ecto.Changeset.t()}
	defp add_to_block(%User{} = user, %User{} = blocked) do
	UserRelationship.create_block(user, blocked)
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:ok, nil} \| {:error, Ecto.Changeset.t()}
	defp remove_from_block(%User{} = user, %User{} = blocked) do
	UserRelationship.delete_block(user, blocked)
	end

	defp add_to_mutes(%User{} = user, %User{} = muted_user, notifications?) do
	with {:ok, user_mute} <- UserRelationship.create_mute(user, muted_user),
	{:ok, user_notification_mute} <-
	(notifications? && UserRelationship.create_notification_mute(user, muted_user)) \|\|
	{:ok, nil} do
	{:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
	end
	end

	defp remove_from_mutes(user, %User{} = muted_user) do
	with {:ok, user_mute} <- UserRelationship.delete_mute(user, muted_user),
	{:ok, user_notification_mute} <-
	UserRelationship.delete_notification_mute(user, muted_user) do
	{:ok, [user_mute, user_notification_mute]}
	end
	end

	def set_invisible(user, invisible) do
	params = %{invisible: invisible}

	user
	\|> cast(params, [:invisible])
	\|> validate_required([:invisible])
	\|> update_and_set_cache()
	end
	end
	diff --git a/lib/pleroma/user/notification_setting.ex b/lib/pleroma/user/notification_setting.ex
	new file mode 100644
	index 000000000..f0899613e
	--- /dev/null
	+++ b/lib/pleroma/user/notification_setting.ex
	@@ -0,0 +1,40 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.User.NotificationSetting do
	+ use Ecto.Schema
	+ import Ecto.Changeset
	+
	+ @derive Jason.Encoder
	+ @primary_key false
	+
	+ embedded_schema do
	+ field(:followers, :boolean, default: true)
	+ field(:follows, :boolean, default: true)
	+ field(:non_follows, :boolean, default: true)
	+ field(:non_followers, :boolean, default: true)
	+ field(:privacy_option, :boolean, default: false)
	+ end
	+
	+ def changeset(schema, params) do
	+ schema
	+ \|> cast(prepare_attrs(params), [
	+ :followers,
	+ :follows,
	+ :non_follows,
	+ :non_followers,
	+ :privacy_option
	+ ])
	+ end
	+
	+ defp prepare_attrs(params) do
	+ Enum.reduce(params, %{}, fn
	+ {k, v}, acc when is_binary(v) ->
	+ Map.put(acc, k, String.downcase(v))
	+
	+ {k, v}, acc ->
	+ Map.put(acc, k, v)
	+ end)
	+ end
	+end
	diff --git a/lib/pleroma/web/endpoint.ex b/lib/pleroma/web/endpoint.ex
	index 49735b5c2..bbea31682 100644
	--- a/lib/pleroma/web/endpoint.ex
	+++ b/lib/pleroma/web/endpoint.ex
	@@ -1,134 +1,127 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	plug(Pleroma.Plugs.SetLocalePlug)
	plug(CORSPlug)
	plug(Pleroma.Plugs.HTTPSecurityPlug)
	plug(Pleroma.Plugs.UploadedMedia)

	@static_cache_control "public max-age=86400 must-revalidate"

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

	# Serve at "/" the static files from "priv/static" directory.
	#
	# You should set gzip to true if you are running phoenix.digest
	# when deploying your static files in production.
	plug(
	Plug.Static,
	at: "/",
	from: :pleroma,
	only:
	~w(index.html robots.txt static finmoji emoji packs sounds images instance sw.js sw-pleroma.js favicon.png schemas doc),
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	gzip: true,
	cache_control_for_etags: @static_cache_control,
	headers: %{
	"cache-control" => @static_cache_control
	}
	)

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

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

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

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

	- plug(
	- Plug.Parsers,
	- parsers: [:urlencoded, :multipart, :json],
	- pass: ["/"],
	- json_decoder: Jason,
	- length: Pleroma.Config.get([:instance, :upload_limit]),
	- body_reader: {Pleroma.Web.Plugs.DigestPlug, :read_body, []}
	- )
	+ plug(Pleroma.Plugs.Parsers)

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

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

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

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

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

	plug(Pleroma.Plugs.RemoteIp)

	defmodule Instrumenter do
	use Prometheus.PhoenixInstrumenter
	end

	defmodule PipelineInstrumenter do
	use Prometheus.PlugPipelineInstrumenter
	end

	defmodule MetricsExporter do
	use Prometheus.PlugExporter
	end

	plug(PipelineInstrumenter)
	plug(MetricsExporter)

	plug(Pleroma.Web.Router)

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

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

	def websocket_url do
	String.replace_leading(url(), "http", "ws")
	end
	end
	diff --git a/lib/pleroma/web/push/impl.ex b/lib/pleroma/web/push/impl.ex
	index a6a924d02..34ec1d8d9 100644
	--- a/lib/pleroma/web/push/impl.ex
	+++ b/lib/pleroma/web/push/impl.ex
	@@ -1,143 +1,160 @@
	# 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", "Move"]

	@doc "Performs sending notifications for user subscriptions"
	@spec perform(Notification.t()) :: list(any) \| :error
	def perform(
	%{
	- activity: %{data: %{"type" => activity_type}, id: activity_id} = activity,
	- user_id: user_id
	+ activity: %{data: %{"type" => activity_type}} = activity,
	+ user: %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)
	object = Object.normalize(activity)
	user = User.get_cached_by_id(user_id)
	direct_conversation_id = Activity.direct_conversation_id(activity, user)

	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, object),
	notification_id: notif.id,
	notification_type: type,
	icon: avatar_url,
	preferred_locale: "en",
	pleroma: %{
	- activity_id: activity_id,
	+ activity_id: notif.activity.id,
	direct_conversation_id: direct_conversation_id
	}
	}
	+ \|> Map.merge(build_content(notif, actor, object))
	\|> Jason.encode!()
	\|> push_message(build_sub(subscription), gcm_api_key, subscription)
	end
	end

	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 build_content(
	+ %{
	+ activity: %{data: %{"directMessage" => true}},
	+ user: %{notification_settings: %{privacy_option: true}}
	+ },
	+ actor,
	+ _
	+ ) do
	+ %{title: "New Direct Message", body: "@#{actor.nickname}"}
	+ end
	+
	+ def build_content(notif, actor, object) do
	+ %{
	+ title: format_title(notif),
	+ body: format_body(notif, actor, object)
	+ }
	+ end
	+
	def format_body(
	%{activity: %{data: %{"type" => "Create"}}},
	actor,
	%{data: %{"content" => content}}
	) do
	"@#{actor.nickname}: #{Utils.scrub_html_and_truncate(content, 80)}"
	end

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

	def format_body(
	%{activity: %{data: %{"type" => type}}},
	actor,
	_object
	)
	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: %{"directMessage" => true}}}) do
	"New Direct Message"
	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/workers/web_pusher_worker.ex b/lib/pleroma/workers/web_pusher_worker.ex
	index 61b451e3e..a978c4013 100644
	--- a/lib/pleroma/workers/web_pusher_worker.ex
	+++ b/lib/pleroma/workers/web_pusher_worker.ex
	@@ -1,20 +1,20 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.WebPusherWorker do
	alias Pleroma.Notification
	alias Pleroma.Repo

	use Pleroma.Workers.WorkerHelper, queue: "web_push"

	@impl Oban.Worker
	def perform(%{"op" => "web_push", "notification_id" => notification_id}, _job) do
	notification =
	Notification
	\|> Repo.get(notification_id)
	- \|> Repo.preload([:activity])
	+ \|> Repo.preload([:activity, :user])

	Pleroma.Web.Push.Impl.perform(notification)
	end
	end
	diff --git a/priv/scrubbers/default.ex b/priv/scrubbers/default.ex
	new file mode 100644
	index 000000000..ea0480dcd
	--- /dev/null
	+++ b/priv/scrubbers/default.ex
	@@ -0,0 +1,93 @@
	+defmodule Pleroma.HTML.Scrubber.Default do
	+ @doc "The default HTML scrubbing policy: no "
	+
	+ require FastSanitize.Sanitizer.Meta
	+ alias FastSanitize.Sanitizer.Meta
	+
	+ # credo:disable-for-previous-line
	+ # No idea how to fix this one…
	+
	+ @valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])
	+
	+ Meta.strip_comments()
	+
	+ Meta.allow_tag_with_uri_attributes(:a, ["href", "data-user", "data-tag"], @valid_schemes)
	+
	+ Meta.allow_tag_with_this_attribute_values(:a, "class", [
	+ "hashtag",
	+ "u-url",
	+ "mention",
	+ "u-url mention",
	+ "mention u-url"
	+ ])
	+
	+ Meta.allow_tag_with_this_attribute_values(:a, "rel", [
	+ "tag",
	+ "nofollow",
	+ "noopener",
	+ "noreferrer",
	+ "ugc"
	+ ])
	+
	+ Meta.allow_tag_with_these_attributes(:a, ["name", "title"])
	+
	+ Meta.allow_tag_with_these_attributes(:abbr, ["title"])
	+
	+ Meta.allow_tag_with_these_attributes(:b, [])
	+ Meta.allow_tag_with_these_attributes(:blockquote, [])
	+ Meta.allow_tag_with_these_attributes(:br, [])
	+ Meta.allow_tag_with_these_attributes(:code, [])
	+ Meta.allow_tag_with_these_attributes(:del, [])
	+ Meta.allow_tag_with_these_attributes(:em, [])
	+ Meta.allow_tag_with_these_attributes(:i, [])
	+ Meta.allow_tag_with_these_attributes(:li, [])
	+ Meta.allow_tag_with_these_attributes(:ol, [])
	+ Meta.allow_tag_with_these_attributes(:p, [])
	+ Meta.allow_tag_with_these_attributes(:pre, [])
	+ Meta.allow_tag_with_these_attributes(:strong, [])
	+ Meta.allow_tag_with_these_attributes(:sub, [])
	+ Meta.allow_tag_with_these_attributes(:sup, [])
	+ Meta.allow_tag_with_these_attributes(:u, [])
	+ Meta.allow_tag_with_these_attributes(:ul, [])
	+
	+ Meta.allow_tag_with_this_attribute_values(:span, "class", ["h-card"])
	+ Meta.allow_tag_with_these_attributes(:span, [])
	+
	+ @allow_inline_images Pleroma.Config.get([:markup, :allow_inline_images])
	+
	+ if @allow_inline_images do
	+ # restrict img tags to http/https only, because of MediaProxy.
	+ Meta.allow_tag_with_uri_attributes(:img, ["src"], ["http", "https"])
	+
	+ Meta.allow_tag_with_these_attributes(:img, [
	+ "width",
	+ "height",
	+ "class",
	+ "title",
	+ "alt"
	+ ])
	+ end
	+
	+ if Pleroma.Config.get([:markup, :allow_tables]) do
	+ Meta.allow_tag_with_these_attributes(:table, [])
	+ Meta.allow_tag_with_these_attributes(:tbody, [])
	+ Meta.allow_tag_with_these_attributes(:td, [])
	+ Meta.allow_tag_with_these_attributes(:th, [])
	+ Meta.allow_tag_with_these_attributes(:thead, [])
	+ Meta.allow_tag_with_these_attributes(:tr, [])
	+ end
	+
	+ if Pleroma.Config.get([:markup, :allow_headings]) do
	+ Meta.allow_tag_with_these_attributes(:h1, [])
	+ Meta.allow_tag_with_these_attributes(:h2, [])
	+ Meta.allow_tag_with_these_attributes(:h3, [])
	+ Meta.allow_tag_with_these_attributes(:h4, [])
	+ Meta.allow_tag_with_these_attributes(:h5, [])
	+ end
	+
	+ if Pleroma.Config.get([:markup, :allow_fonts]) do
	+ Meta.allow_tag_with_these_attributes(:font, ["face"])
	+ end
	+
	+ Meta.strip_everything_not_covered()
	+end
	diff --git a/priv/scrubbers/links_only.ex b/priv/scrubbers/links_only.ex
	new file mode 100644
	index 000000000..b30a00589
	--- /dev/null
	+++ b/priv/scrubbers/links_only.ex
	@@ -0,0 +1,27 @@
	+defmodule Pleroma.HTML.Scrubber.LinksOnly do
	+ @moduledoc """
	+ An HTML scrubbing policy which limits to links only.
	+ """
	+
	+ @valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])
	+
	+ require FastSanitize.Sanitizer.Meta
	+ alias FastSanitize.Sanitizer.Meta
	+
	+ Meta.strip_comments()
	+
	+ # links
	+ Meta.allow_tag_with_uri_attributes(:a, ["href"], @valid_schemes)
	+
	+ Meta.allow_tag_with_this_attribute_values(:a, "rel", [
	+ "tag",
	+ "nofollow",
	+ "noopener",
	+ "noreferrer",
	+ "me",
	+ "ugc"
	+ ])
	+
	+ Meta.allow_tag_with_these_attributes(:a, ["name", "title"])
	+ Meta.strip_everything_not_covered()
	+end
	diff --git a/priv/scrubbers/media_proxy.ex b/priv/scrubbers/media_proxy.ex
	new file mode 100644
	index 000000000..5dbe57666
	--- /dev/null
	+++ b/priv/scrubbers/media_proxy.ex
	@@ -0,0 +1,32 @@
	+defmodule Pleroma.HTML.Transform.MediaProxy do
	+ @moduledoc "Transforms inline image URIs to use MediaProxy."
	+
	+ alias Pleroma.Web.MediaProxy
	+
	+ def before_scrub(html), do: html
	+
	+ def scrub_attribute(:img, {"src", "http" <> target}) do
	+ media_url =
	+ ("http" <> target)
	+ \|> MediaProxy.url()
	+
	+ {"src", media_url}
	+ end
	+
	+ def scrub_attribute(_tag, attribute), do: attribute
	+
	+ def scrub({:img, attributes, children}) do
	+ attributes =
	+ attributes
	+ \|> Enum.map(fn attr -> scrub_attribute(:img, attr) end)
	+ \|> Enum.reject(&is_nil(&1))
	+
	+ {:img, attributes, children}
	+ end
	+
	+ def scrub({:comment, _text, _children}), do: ""
	+
	+ def scrub({tag, attributes, children}), do: {tag, attributes, children}
	+ def scrub({_tag, children}), do: children
	+ def scrub(text), do: text
	+end
	diff --git a/priv/scrubbers/twitter_text.ex b/priv/scrubbers/twitter_text.ex
	new file mode 100644
	index 000000000..c4e796cad
	--- /dev/null
	+++ b/priv/scrubbers/twitter_text.ex
	@@ -0,0 +1,57 @@
	+defmodule Pleroma.HTML.Scrubber.TwitterText do
	+ @moduledoc """
	+ An HTML scrubbing policy which limits to twitter-style text. Only
	+ paragraphs, breaks and links are allowed through the filter.
	+ """
	+
	+ @valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])
	+
	+ require FastSanitize.Sanitizer.Meta
	+ alias FastSanitize.Sanitizer.Meta
	+
	+ Meta.strip_comments()
	+
	+ # links
	+ Meta.allow_tag_with_uri_attributes(:a, ["href", "data-user", "data-tag"], @valid_schemes)
	+
	+ Meta.allow_tag_with_this_attribute_values(:a, "class", [
	+ "hashtag",
	+ "u-url",
	+ "mention",
	+ "u-url mention",
	+ "mention u-url"
	+ ])
	+
	+ Meta.allow_tag_with_this_attribute_values(:a, "rel", [
	+ "tag",
	+ "nofollow",
	+ "noopener",
	+ "noreferrer"
	+ ])
	+
	+ Meta.allow_tag_with_these_attributes(:a, ["name", "title"])
	+
	+ # paragraphs and linebreaks
	+ Meta.allow_tag_with_these_attributes(:br, [])
	+ Meta.allow_tag_with_these_attributes(:p, [])
	+
	+ # microformats
	+ Meta.allow_tag_with_this_attribute_values(:span, "class", ["h-card"])
	+ Meta.allow_tag_with_these_attributes(:span, [])
	+
	+ # allow inline images for custom emoji
	+ if Pleroma.Config.get([:markup, :allow_inline_images]) do
	+ # restrict img tags to http/https only, because of MediaProxy.
	+ Meta.allow_tag_with_uri_attributes(:img, ["src"], ["http", "https"])
	+
	+ Meta.allow_tag_with_these_attributes(:img, [
	+ "width",
	+ "height",
	+ "class",
	+ "title",
	+ "alt"
	+ ])
	+ end
	+
	+ Meta.strip_everything_not_covered()
	+end
	diff --git a/test/notification_test.exs b/test/notification_test.exs
	index 827ac4f06..ffa3d4b8c 100644
	--- a/test/notification_test.exs
	+++ b/test/notification_test.exs
	@@ -1,759 +1,771 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase

	import Pleroma.Factory

	alias Pleroma.Notification
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.Streamer

	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} =
	CommonAPI.post(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} = CommonAPI.post(user, %{"status" => "Akariiiin"})
	{:ok, [notification]} = Notification.create_notifications(status)

	assert notification.user_id == subscriber.id
	end

	test "does not create a notification for subscribed users if status is a reply" do
	user = insert(:user)
	other_user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, other_user)

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

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

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

	subscriber_notifications = Notification.for_user(subscriber)
	assert Enum.empty?(subscriber_notifications)
	end
	end

	describe "create_notification" do
	@tag needs_streamer: true
	test "it creates a notification for user and send to the 'user' and the 'user:notification' stream" do
	user = insert(:user)
	task = Task.async(fn -> assert_receive {:text, _}, 4_000 end)
	task_user_notification = Task.async(fn -> assert_receive {:text, _}, 4_000 end)
	Streamer.add_socket("user", %{transport_pid: task.pid, assigns: %{user: user}})

	Streamer.add_socket(
	"user:notification",
	%{transport_pid: task_user_notification.pid, assigns: %{user: user}}
	)

	activity = insert(:note_activity)

	notify = Notification.create_notification(activity, user)
	assert notify.user_id == user.id
	Task.await(task)
	Task.await(task_user_notification)
	end

	test "it creates 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_relationship} = User.block(user, author)

	assert Notification.create_notification(activity, user)
	end

	test "it creates 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 Notification.create_notification(activity, muter)
	end

	test "notification created if user is muted without notifications" do
	muter = insert(:user)
	muted = insert(:user)

	{:ok, _user_relationships} = User.mute(muter, muted, false)

	{:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})

	assert Notification.create_notification(activity, muter)
	end

	test "it creates 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 Notification.create_notification(activity, muter)
	end

	test "it disables notifications from followers" do
	follower = insert(:user)
	- followed = insert(:user, notification_settings: %{"followers" => false})
	+
	+ followed =
	+ insert(:user, notification_settings: %Pleroma.User.NotificationSetting{followers: false})
	+
	User.follow(follower, followed)
	{:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it disables notifications from non-followers" do
	follower = insert(:user)
	- followed = insert(:user, notification_settings: %{"non_followers" => false})
	+
	+ followed =
	+ insert(:user,
	+ notification_settings: %Pleroma.User.NotificationSetting{non_followers: false}
	+ )
	+
	{:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it disables notifications from people the user follows" do
	- follower = insert(:user, notification_settings: %{"follows" => false})
	+ follower =
	+ insert(:user, notification_settings: %Pleroma.User.NotificationSetting{follows: false})
	+
	followed = insert(:user)
	User.follow(follower, followed)
	follower = Repo.get(User, follower.id)
	{:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
	refute Notification.create_notification(activity, follower)
	end

	test "it disables notifications from people the user does not follow" do
	- follower = insert(:user, notification_settings: %{"non_follows" => false})
	+ follower =
	+ insert(:user, notification_settings: %Pleroma.User.NotificationSetting{non_follows: false})
	+
	followed = insert(:user)
	{:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
	refute 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"])

	refute 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} = CommonAPI.follow(user, followed_user)
	Notification.create_notification(activity, followed_user)
	CommonAPI.unfollow(user, followed_user)
	{:ok, _, _, activity_dupe} = CommonAPI.follow(user, followed_user)
	refute Notification.create_notification(activity_dupe, followed_user)
	end

	test "it doesn't create duplicate notifications for follow+subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(subscriber, user)
	User.subscribe(subscriber, user)
	{:ok, status} = CommonAPI.post(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} = CommonAPI.post(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} = CommonAPI.post(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} = CommonAPI.post(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} = CommonAPI.post(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} = CommonAPI.post(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} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !"
	})

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

	{:ok, activity} =
	CommonAPI.post(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} =
	CommonAPI.post(user, %{
	"status" => "hey @#{other_user.nickname}!"
	})

	{:ok, _activity} =
	CommonAPI.post(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} =
	CommonAPI.post(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 "for_user_since/2" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

	test "Returns recent notifications" do
	user1 = insert(:user)
	user2 = insert(:user)

	Enum.each(0..10, fn i ->
	{:ok, _activity} =
	CommonAPI.post(user1, %{
	"status" => "hey ##{i} @#{user2.nickname}!"
	})
	end)

	{old, new} = Enum.split(Notification.for_user(user2), 5)

	Enum.each(old, fn notification ->
	notification
	\|> cast(%{updated_at: days_ago(10)}, [:updated_at])
	\|> Pleroma.Repo.update!()
	end)

	recent_notifications_ids =
	user2
	\|> Notification.for_user_since(
	NaiveDateTime.add(NaiveDateTime.utc_now(), -5 * 86_400, :second)
	)
	\|> Enum.map(& &1.id)

	Enum.each(old, fn %{id: id} ->
	refute id in recent_notifications_ids
	end)

	Enum.each(new, fn %{id: id} ->
	assert id in recent_notifications_ids
	end)
	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

	test "notifications are deleted if a local user is deleted" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}", "visibility" => "direct"})

	refute Enum.empty?(Notification.for_user(other_user))

	{:ok, job} = User.delete(user)
	ObanHelpers.perform(job)

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

	test "notifications are deleted if a remote user is deleted" do
	remote_user = insert(:user)
	local_user = insert(:user)

	dm_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"type" => "Create",
	"actor" => remote_user.ap_id,
	"id" => remote_user.ap_id <> "/activities/test",
	"to" => [local_user.ap_id],
	"cc" => [],
	"object" => %{
	"type" => "Note",
	"content" => "Hello!",
	"tag" => [
	%{
	"type" => "Mention",
	"href" => local_user.ap_id,
	"name" => "@#{local_user.nickname}"
	}
	],
	"to" => [local_user.ap_id],
	"cc" => [],
	"attributedTo" => remote_user.ap_id
	}
	}

	{:ok, _dm_activity} = Transmogrifier.handle_incoming(dm_message)

	refute Enum.empty?(Notification.for_user(local_user))

	delete_user_message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => remote_user.ap_id <> "/activities/delete",
	"actor" => remote_user.ap_id,
	"type" => "Delete",
	"object" => remote_user.ap_id
	}

	{:ok, _delete_activity} = Transmogrifier.handle_incoming(delete_user_message)
	ObanHelpers.perform_all()

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

	test "move activity generates a notification" do
	%{ap_id: old_ap_id} = old_user = insert(:user)
	%{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
	follower = insert(:user)
	other_follower = insert(:user, %{allow_following_move: false})

	User.follow(follower, old_user)
	User.follow(other_follower, old_user)

	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	ObanHelpers.perform_all()

	assert [] = Notification.for_user(follower)

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(follower, %{with_move: true})

	assert [] = Notification.for_user(other_follower)

	assert [
	%{
	activity: %{
	data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
	}
	}
	] = Notification.for_user(other_follower, %{with_move: true})
	end
	end

	describe "for_user" do
	test "it returns notifications for muted user without notifications" do
	user = insert(:user)
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted, false)

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

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

	test "it doesn't return notifications for muted user with notifications" do
	user = insert(:user)
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

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

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for blocked user" do
	user = insert(:user)
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

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

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notificatitons for blocked domain" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

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

	assert Notification.for_user(user) == []
	end

	test "it doesn't return notifications for muted thread" do
	user = insert(:user)
	another_user = insert(:user)

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

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert Notification.for_user(user) == []
	end

	test "it returns notifications from a muted user when with_muted is set" do
	user = insert(:user)
	muted = insert(:user)
	{:ok, _user_relationships} = User.mute(user, muted)

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

	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end

	test "it doesn't return notifications from a blocked user when with_muted is set" do
	user = insert(:user)
	blocked = insert(:user)
	{:ok, _user_relationship} = User.block(user, blocked)

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

	assert length(Notification.for_user(user, %{with_muted: true})) == 0
	end

	test "it doesn't return notifications from a domain-blocked user when with_muted is set" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")
	{:ok, user} = User.block_domain(user, "some-domain.com")

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

	assert length(Notification.for_user(user, %{with_muted: true})) == 0
	end

	test "it returns notifications from muted threads when with_muted is set" do
	user = insert(:user)
	another_user = insert(:user)

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

	{:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
	assert length(Notification.for_user(user, %{with_muted: true})) == 1
	end
	end
	end
	diff --git a/test/support/builders/user_builder.ex b/test/support/builders/user_builder.ex
	index 6da16f71a..fcfea666f 100644
	--- a/test/support/builders/user_builder.ex
	+++ b/test/support/builders/user_builder.ex
	@@ -1,24 +1,25 @@
	defmodule Pleroma.Builders.UserBuilder do
	alias Pleroma.Repo
	alias Pleroma.User

	def build(data \\ %{}) do
	user = %User{
	email: "test@example.org",
	name: "Test Name",
	nickname: "testname",
	password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
	bio: "A tester.",
	ap_id: "some id",
	- last_digest_emailed_at: NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	+ last_digest_emailed_at: NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	+ notification_settings: %Pleroma.User.NotificationSetting{}
	}

	Map.merge(user, data)
	end

	def insert(data \\ %{}) do
	{:ok, user} = Repo.insert(build(data))
	User.invalidate_cache(user)
	{:ok, user}
	end
	end
	diff --git a/test/support/factory.ex b/test/support/factory.ex
	index 35ba523a1..314f26ec9 100644
	--- a/test/support/factory.ex
	+++ b/test/support/factory.ex
	@@ -1,399 +1,400 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	def participation_factory do
	conversation = insert(:conversation)
	user = insert(:user)

	%Pleroma.Conversation.Participation{
	conversation: conversation,
	user: user,
	read: false
	}
	end

	def conversation_factory do
	%Pleroma.Conversation{
	ap_id: sequence(:ap_id, &"https://some_conversation/#{&1}")
	}
	end

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

	%{
	user
	\| ap_id: User.ap_id(user),
	follower_address: User.ap_followers(user),
	following_address: User.ap_following(user)
	}
	end

	def user_relationship_factory(attrs \\ %{}) do
	source = attrs[:source] \|\| insert(:user)
	target = attrs[:target] \|\| insert(:user)
	relationship_type = attrs[:relationship_type] \|\| :block

	%Pleroma.UserRelationship{
	source_id: source.id,
	target_id: target.id,
	relationship_type: relationship_type
	}
	end

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

	user = attrs[:user] \|\| insert(:user)

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

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

	def audio_factory(attrs \\ %{}) do
	text = sequence(:text, &"lain radio episode #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Audio",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"artist" => "lain",
	"title" => text,
	"album" => "lain radio",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"actor" => user.ap_id,
	"length" => 180_000
	}

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

	def listen_factory do
	audio = insert(:audio)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Listen",
	"actor" => audio.data["actor"],
	"to" => audio.data["to"],
	"object" => audio.data,
	"published" => audio.data["published"]
	}

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

	def direct_note_factory do
	user2 = insert(:user)

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

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

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

	%Pleroma.Object{
	data: data
	}
	end

	def direct_note_activity_factory do
	dm = insert(:direct_note)

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

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

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

	data_attrs = attrs[:data_attrs] \|\| %{}
	attrs = Map.drop(attrs, [:user, :note, :data_attrs])

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

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	\|> Map.merge(attrs)
	end

	defp expiration_offset_by_minutes(attrs, minutes) do
	scheduled_at =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(minutes), :millisecond)
	\|> NaiveDateTime.truncate(:second)

	%Pleroma.ActivityExpiration{}
	\|> Map.merge(attrs)
	\|> Map.put(:scheduled_at, scheduled_at)
	end

	def expiration_in_the_past_factory(attrs \\ %{}) do
	expiration_offset_by_minutes(attrs, -60)
	end

	def expiration_in_the_future_factory(attrs \\ %{}) do
	expiration_offset_by_minutes(attrs, 61)
	end

	def article_activity_factory do
	article = insert(:article)

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

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

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

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

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

	def like_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	object = Object.normalize(note_activity)
	user = insert(:user)

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

	%Pleroma.Activity{
	data: data
	}
	end

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

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

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

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

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

	def oauth_token_factory do
	oauth_app = insert(:oauth_app)

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

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

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

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

	def scheduled_activity_factory do
	%Pleroma.ScheduledActivity{
	user: build(:user),
	scheduled_at: NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(60), :millisecond),
	params: build(:note) \|> Map.from_struct() \|> Map.get(:data)
	}
	end

	def registration_factory do
	user = insert(:user)

	%Pleroma.Registration{
	user: user,
	provider: "twitter",
	uid: "171799000",
	info: %{
	"name" => "John Doe",
	"email" => "john@doe.com",
	"nickname" => "johndoe",
	"description" => "My bio"
	}
	}
	end

	def config_factory do
	%Pleroma.Web.AdminAPI.Config{
	key: sequence(:key, &"some_key_#{&1}"),
	group: "pleroma",
	value:
	sequence(
	:value,
	fn key ->
	:erlang.term_to_binary(%{another_key: "#{key}somevalue", another: "#{key}somevalue"})
	end
	)
	}
	end

	def marker_factory do
	%Pleroma.Marker{
	user: build(:user),
	timeline: "notifications",
	lock_version: 0,
	last_read_id: "1"
	}
	end
	end
	diff --git a/test/user/notification_setting_test.exs b/test/user/notification_setting_test.exs
	new file mode 100644
	index 000000000..4744d7b4a
	--- /dev/null
	+++ b/test/user/notification_setting_test.exs
	@@ -0,0 +1,21 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.User.NotificationSettingTest do
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.User.NotificationSetting
	+
	+ describe "changeset/2" do
	+ test "sets valid privacy option" do
	+ changeset =
	+ NotificationSetting.changeset(
	+ %NotificationSetting{},
	+ %{"privacy_option" => true}
	+ )
	+
	+ assert %Ecto.Changeset{valid?: true} = changeset
	+ end
	+ end
	+end
	diff --git a/test/user_search_test.exs b/test/user_search_test.exs
	index 98841dbbd..821858476 100644
	--- a/test/user_search_test.exs
	+++ b/test/user_search_test.exs
	@@ -1,286 +1,287 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserSearchTest do
	alias Pleroma.Repo
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory

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

	describe "User.search" do
	test "excluded invisible users from results" do
	user = insert(:user, %{nickname: "john t1000"})
	insert(:user, %{invisible: true, nickname: "john t800"})

	[found_user] = User.search("john")
	assert found_user.id == user.id
	end

	test "accepts limit parameter" do
	Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
	assert length(User.search("john", limit: 3)) == 3
	assert length(User.search("john")) == 5
	end

	test "accepts offset parameter" do
	Enum.each(0..4, &insert(:user, %{nickname: "john#{&1}"}))
	assert length(User.search("john", limit: 3)) == 3
	assert length(User.search("john", limit: 3, offset: 3)) == 2
	end

	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, 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, 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 followers of user by partial name" do
	u1 = insert(:user)
	u2 = insert(:user, %{name: "Jimi"})
	follower_jimi = insert(:user, %{name: "Jimi Hendrix"})
	follower_lizz = insert(:user, %{name: "Lizz Wright"})
	friend = insert(:user, %{name: "Jimi"})

	{:ok, follower_jimi} = User.follow(follower_jimi, u1)
	{:ok, _follower_lizz} = User.follow(follower_lizz, u2)
	{:ok, u1} = User.follow(u1, friend)

	assert Enum.map(User.search("jimi", following: true, for_user: u1), & &1.id) == [
	follower_jimi.id
	]

	assert User.search("lizz", following: true, for_user: u1) == []
	end

	test "find local and remote users for authenticated users" do
	u1 = insert(:user, %{name: "lain"})
	u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
	u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})

	results =
	"lain"
	\|> User.search(for_user: u1)
	\|> Enum.map(& &1.id)
	\|> Enum.sort()

	assert [u1.id, u2.id, u3.id] == results
	end

	test "find only local users for unauthenticated users" do
	%{id: id} = insert(:user, %{name: "lain"})
	insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
	insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})

	assert [%{id: ^id}] = User.search("lain")
	end

	test "find only local users for authenticated users when `limit_to_local_content` is `:all`" do
	Pleroma.Config.put([:instance, :limit_to_local_content], :all)

	%{id: id} = insert(:user, %{name: "lain"})
	insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
	insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})

	assert [%{id: ^id}] = User.search("lain")

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

	test "find all users for unauthenticated users when `limit_to_local_content` is `false`" do
	Pleroma.Config.put([:instance, :limit_to_local_content], false)

	u1 = insert(:user, %{name: "lain"})
	u2 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social", local: false})
	u3 = insert(:user, %{nickname: "lain@pleroma.soykaf.com", local: false})

	results =
	"lain"
	\|> User.search()
	\|> Enum.map(& &1.id)
	\|> Enum.sort()

	assert [u1.id, u2.id, u3.id] == results

	Pleroma.Config.put([:instance, :limit_to_local_content], :unauthenticated)
	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
	user = insert(:user)

	results =
	User.search("http://mastodon.example.org/users/admin", resolve: true, for_user: user)

	result = results \|> List.first()

	user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")

	assert length(results) == 1

	expected =
	result
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	\|> Map.put(:last_digest_emailed_at, nil)
	+ \|> Map.put(:notification_settings, nil)

	assert user == expected
	end

	test "excludes a blocked users from search result" do
	user = insert(:user, %{nickname: "Bill"})

	[blocked_user \| users] = Enum.map(0..3, &insert(:user, %{nickname: "john#{&1}"}))

	blocked_user2 =
	insert(
	:user,
	%{nickname: "john awful", ap_id: "https://awful-and-rude-instance.com/user/bully"}
	)

	User.block_domain(user, "awful-and-rude-instance.com")
	User.block(user, blocked_user)

	account_ids = User.search("john", for_user: refresh_record(user)) \|> collect_ids

	assert account_ids == collect_ids(users)
	refute Enum.member?(account_ids, blocked_user.id)
	refute Enum.member?(account_ids, blocked_user2.id)
	assert length(account_ids) == 3
	end

	test "local user has the same search_rank as for users with the same nickname, but another domain" do
	user = insert(:user)
	insert(:user, nickname: "lain@mastodon.social")
	insert(:user, nickname: "lain")
	insert(:user, nickname: "lain@pleroma.social")

	assert User.search("lain@localhost", resolve: true, for_user: user)
	\|> Enum.each(fn u -> u.search_rank == 0.5 end)
	end

	test "localhost is the part of the domain" do
	user = insert(:user)
	insert(:user, nickname: "another@somedomain")
	insert(:user, nickname: "lain")
	insert(:user, nickname: "lain@examplelocalhost")

	result = User.search("lain@examplelocalhost", resolve: true, for_user: user)
	assert Enum.each(result, fn u -> u.search_rank == 0.5 end)
	assert length(result) == 2
	end

	test "local user search with users" do
	user = insert(:user)
	local_user = insert(:user, nickname: "lain")
	insert(:user, nickname: "another@localhost.com")
	insert(:user, nickname: "localhost@localhost.com")

	[result] = User.search("lain@localhost", resolve: true, for_user: user)
	assert Map.put(result, :search_rank, nil) \|> Map.put(:search_type, nil) == local_user
	end

	test "works with idna domains" do
	user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))

	results = User.search("lain@zetsubou.みんな", resolve: false, for_user: user)

	result = List.first(results)

	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end

	test "works with idna domains converted input" do
	user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))

	results =
	User.search("lain@zetsubou." <> to_string(:idna.encode("zetsubou.みんな")),
	resolve: false,
	for_user: user
	)

	result = List.first(results)

	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end

	test "works with idna domains and bad chars in domain" do
	user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))

	results =
	User.search("lain@zetsubou!@#$%^&*()+,-/:;<=>?[]'_{}\|~`.みんな",
	resolve: false,
	for_user: user
	)

	result = List.first(results)

	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end

	test "works with idna domains and query as link" do
	user = insert(:user, nickname: "lain@" <> to_string(:idna.encode("zetsubou.みんな")))

	results =
	User.search("https://zetsubou.みんな/users/lain",
	resolve: false,
	for_user: user
	)

	result = List.first(results)

	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end
	end
	end
	diff --git a/test/web/mastodon_api/controllers/notification_controller_test.exs b/test/web/mastodon_api/controllers/notification_controller_test.exs
	index f6d4ab9f0..6635ea7a2 100644
	--- a/test/web/mastodon_api/controllers/notification_controller_test.exs
	+++ b/test/web/mastodon_api/controllers/notification_controller_test.exs
	@@ -1,376 +1,472 @@
	# 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.NotificationControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "list of notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] = json_response(conn, 200)
	assert response == expected_response
	end

	test "getting a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/dismiss", %{"id" => notification.id})

	assert %{} = json_response(conn, 200)
	end

	test "clearing all notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/clear")

	assert %{} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	assert all = json_response(conn, 200)
	assert all == []
	end

	test "paginates notifications using min_id, since_id, max_id, and limit", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	notification1_id = get_notification_id_by_activity(activity1)
	notification2_id = get_notification_id_by_activity(activity2)
	notification3_id = get_notification_id_by_activity(activity3)
	notification4_id = get_notification_id_by_activity(activity4)

	conn = assign(conn, :user, user)

	# min_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")
	\|> json_response(:ok)

	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result

	# since_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")
	\|> json_response(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	# max_id
	result =
	conn
	\|> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")
	\|> json_response(:ok)

	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
	end

	- test "filters notifications using exclude_visibilities", %{conn: conn} do
	- user = insert(:user)
	- other_user = insert(:user)
	-
	- {:ok, public_activity} =
	- CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "public"})
	-
	- {:ok, direct_activity} =
	- CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
	-
	- {:ok, unlisted_activity} =
	- CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "unlisted"})
	-
	- {:ok, private_activity} =
	- CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "private"})
	-
	- conn = assign(conn, :user, user)
	-
	- conn_res =
	- get(conn, "/api/v1/notifications", %{
	- exclude_visibilities: ["public", "unlisted", "private"]
	- })
	-
	- assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	- assert id == direct_activity.id
	-
	- conn_res =
	- get(conn, "/api/v1/notifications", %{
	- exclude_visibilities: ["public", "unlisted", "direct"]
	- })
	-
	- assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	- assert id == private_activity.id
	-
	- conn_res =
	- get(conn, "/api/v1/notifications", %{
	- exclude_visibilities: ["public", "private", "direct"]
	- })
	-
	- assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	- assert id == unlisted_activity.id
	-
	- conn_res =
	- get(conn, "/api/v1/notifications", %{
	- exclude_visibilities: ["unlisted", "private", "direct"]
	- })
	-
	- assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	- assert id == public_activity.id
	+ describe "exclude_visibilities" do
	+ test "filters notifications for mentions", %{conn: conn} do
	+ user = insert(:user)
	+ other_user = insert(:user)
	+
	+ {:ok, public_activity} =
	+ CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "public"})
	+
	+ {:ok, direct_activity} =
	+ CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
	+
	+ {:ok, unlisted_activity} =
	+ CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "unlisted"})
	+
	+ {:ok, private_activity} =
	+ CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "private"})
	+
	+ conn = assign(conn, :user, user)
	+
	+ conn_res =
	+ get(conn, "/api/v1/notifications", %{
	+ exclude_visibilities: ["public", "unlisted", "private"]
	+ })
	+
	+ assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	+ assert id == direct_activity.id
	+
	+ conn_res =
	+ get(conn, "/api/v1/notifications", %{
	+ exclude_visibilities: ["public", "unlisted", "direct"]
	+ })
	+
	+ assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	+ assert id == private_activity.id
	+
	+ conn_res =
	+ get(conn, "/api/v1/notifications", %{
	+ exclude_visibilities: ["public", "private", "direct"]
	+ })
	+
	+ assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	+ assert id == unlisted_activity.id
	+
	+ conn_res =
	+ get(conn, "/api/v1/notifications", %{
	+ exclude_visibilities: ["unlisted", "private", "direct"]
	+ })
	+
	+ assert [%{"status" => %{"id" => id}}] = json_response(conn_res, 200)
	+ assert id == public_activity.id
	+ end
	+
	+ test "filters notifications for Like activities", %{conn: conn} do
	+ user = insert(:user)
	+ other_user = insert(:user)
	+
	+ {:ok, public_activity} =
	+ CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
	+
	+ {:ok, direct_activity} =
	+ CommonAPI.post(other_user, %{"status" => "@#{user.nickname}", "visibility" => "direct"})
	+
	+ {:ok, unlisted_activity} =
	+ CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})
	+
	+ {:ok, private_activity} =
	+ CommonAPI.post(other_user, %{"status" => ".", "visibility" => "private"})
	+
	+ {:ok, _, _} = CommonAPI.favorite(public_activity.id, user)
	+ {:ok, _, _} = CommonAPI.favorite(direct_activity.id, user)
	+ {:ok, _, _} = CommonAPI.favorite(unlisted_activity.id, user)
	+ {:ok, _, _} = CommonAPI.favorite(private_activity.id, user)
	+
	+ activity_ids =
	+ conn
	+ \|> assign(:user, other_user)
	+ \|> get("/api/v1/notifications", %{exclude_visibilities: ["direct"]})
	+ \|> json_response(200)
	+ \|> Enum.map(& &1["status"]["id"])
	+
	+ assert public_activity.id in activity_ids
	+ assert unlisted_activity.id in activity_ids
	+ assert private_activity.id in activity_ids
	+ refute direct_activity.id in activity_ids
	+
	+ activity_ids =
	+ conn
	+ \|> assign(:user, other_user)
	+ \|> get("/api/v1/notifications", %{exclude_visibilities: ["unlisted"]})
	+ \|> json_response(200)
	+ \|> Enum.map(& &1["status"]["id"])
	+
	+ assert public_activity.id in activity_ids
	+ refute unlisted_activity.id in activity_ids
	+ assert private_activity.id in activity_ids
	+ assert direct_activity.id in activity_ids
	+
	+ activity_ids =
	+ conn
	+ \|> assign(:user, other_user)
	+ \|> get("/api/v1/notifications", %{exclude_visibilities: ["private"]})
	+ \|> json_response(200)
	+ \|> Enum.map(& &1["status"]["id"])
	+
	+ assert public_activity.id in activity_ids
	+ assert unlisted_activity.id in activity_ids
	+ refute private_activity.id in activity_ids
	+ assert direct_activity.id in activity_ids
	+
	+ activity_ids =
	+ conn
	+ \|> assign(:user, other_user)
	+ \|> get("/api/v1/notifications", %{exclude_visibilities: ["public"]})
	+ \|> json_response(200)
	+ \|> Enum.map(& &1["status"]["id"])
	+
	+ refute public_activity.id in activity_ids
	+ assert unlisted_activity.id in activity_ids
	+ assert private_activity.id in activity_ids
	+ assert direct_activity.id in activity_ids
	+ end
	+
	+ test "filters notifications for Announce activities", %{conn: conn} do
	+ user = insert(:user)
	+ other_user = insert(:user)
	+
	+ {:ok, public_activity} =
	+ CommonAPI.post(other_user, %{"status" => ".", "visibility" => "public"})
	+
	+ {:ok, unlisted_activity} =
	+ CommonAPI.post(other_user, %{"status" => ".", "visibility" => "unlisted"})
	+
	+ {:ok, _, _} = CommonAPI.repeat(public_activity.id, user)
	+ {:ok, _, _} = CommonAPI.repeat(unlisted_activity.id, user)
	+
	+ activity_ids =
	+ conn
	+ \|> assign(:user, other_user)
	+ \|> get("/api/v1/notifications", %{exclude_visibilities: ["unlisted"]})
	+ \|> json_response(200)
	+ \|> Enum.map(& &1["status"]["id"])
	+
	+ assert public_activity.id in activity_ids
	+ refute unlisted_activity.id in activity_ids
	+ end
	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 = get_notification_id_by_activity(mention_activity)
	favorite_notification_id = get_notification_id_by_activity(favorite_activity)
	reblog_notification_id = get_notification_id_by_activity(reblog_activity)
	follow_notification_id = get_notification_id_by_activity(follow_activity)

	conn = assign(conn, :user, user)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["mention", "favourite", "reblog"]})

	assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["favourite", "reblog", "follow"]})

	assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["reblog", "follow", "mention"]})

	assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["follow", "mention", "favourite"]})

	assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)
	end

	test "destroy multiple", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
	{:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})

	notification1_id = get_notification_id_by_activity(activity1)
	notification2_id = get_notification_id_by_activity(activity2)
	notification3_id = get_notification_id_by_activity(activity3)
	notification4_id = get_notification_id_by_activity(activity4)

	conn = assign(conn, :user, user)

	result =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response(:ok)

	assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result

	conn2 =
	conn
	\|> assign(:user, other_user)

	result =
	conn2
	\|> get("/api/v1/notifications")
	\|> json_response(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	conn_destroy =
	conn
	\|> delete("/api/v1/notifications/destroy_multiple", %{
	"ids" => [notification1_id, notification2_id]
	})

	assert json_response(conn_destroy, 200) == %{}

	result =
	conn2
	\|> get("/api/v1/notifications")
	\|> json_response(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
	end

	test "doesn't see notifications after muting user with notifications", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	conn = assign(conn, :user, user)

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response(conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2)

	conn = assign(build_conn(), :user, user)
	conn = get(conn, "/api/v1/notifications")

	assert json_response(conn, 200) == []
	end

	test "see notifications after muting user without notifications", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	conn = assign(conn, :user, user)

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response(conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2, false)

	conn = assign(build_conn(), :user, user)
	conn = get(conn, "/api/v1/notifications")

	assert length(json_response(conn, 200)) == 1
	end

	test "see notifications after muting user with notifications and with_muted parameter", %{
	conn: conn
	} do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user, user2)
	{:ok, _} = CommonAPI.post(user2, %{"status" => "hey @#{user.nickname}"})

	conn = assign(conn, :user, user)

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response(conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2)

	conn = assign(build_conn(), :user, user)
	conn = get(conn, "/api/v1/notifications", %{"with_muted" => "true"})

	assert length(json_response(conn, 200)) == 1
	end

	test "see move notifications with `with_move` parameter", %{
	conn: conn
	} do
	old_user = insert(:user)
	new_user = insert(:user, also_known_as: [old_user.ap_id])
	follower = insert(:user)

	User.follow(follower, old_user)
	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	Pleroma.Tests.ObanHelpers.perform_all()

	conn =
	conn
	\|> assign(:user, follower)
	\|> get("/api/v1/notifications")

	assert json_response(conn, 200) == []

	conn =
	build_conn()
	\|> assign(:user, follower)
	\|> get("/api/v1/notifications", %{"with_move" => "true"})

	assert length(json_response(conn, 200)) == 1
	end

	defp get_notification_id_by_activity(%{id: id}) do
	Notification
	\|> Repo.get_by(activity_id: id)
	\|> Map.get(:id)
	\|> to_string()
	end
	end
	diff --git a/test/web/mastodon_api/views/account_view_test.exs b/test/web/mastodon_api/views/account_view_test.exs
	index ed6f2ecbd..5e297d129 100644
	--- a/test/web/mastodon_api/views/account_view_test.exs
	+++ b/test/web/mastodon_api/views/account_view_test.exs
	@@ -1,528 +1,522 @@
	# 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.AccountViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView

	test "Represent a user account" do
	source_data = %{
	"tag" => [
	%{
	"type" => "Emoji",
	"icon" => %{"url" => "/file.png"},
	"name" => ":karjalanpiirakka:"
	}
	]
	}

	background_image = %{
	"url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
	}

	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	source_data: source_data,
	background: background_image,
	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: "valid html",
	sensitive: false,
	pleroma: %{
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: "https://example.com/images/asuka_hospital.png",
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user})
	end

	test "Represent the user account for the account owner" do
	user = insert(:user)

	- notification_settings = %{
	- "followers" => true,
	- "follows" => true,
	- "non_follows" => true,
	- "non_followers" => true
	- }
	-
	+ notification_settings = %Pleroma.User.NotificationSetting{}
	privacy = user.default_scope

	assert %{
	pleroma: %{notification_settings: ^notification_settings, allow_following_move: true},
	source: %{privacy: ^privacy}
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	follower_count: 3,
	note_count: 5,
	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: user.bio,
	sensitive: false,
	pleroma: %{
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user})
	end

	test "Represent a deactivated user for an admin" do
	admin = insert(:user, is_admin: true)
	deactivated_user = insert(:user, deactivated: true)
	represented = AccountView.render("show.json", %{user: deactivated_user, for: admin})
	assert represented[:pleroma][:deactivated] == true
	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

	describe "relationship" do
	test "represent a relationship for the following and followed user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationships} = User.mute(user, other_user, true)
	{:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, other_user)

	expected = %{
	id: to_string(other_user.id),
	following: true,
	followed_by: true,
	blocking: false,
	blocked_by: false,
	muting: true,
	muting_notifications: true,
	subscribing: true,
	requested: false,
	domain_blocking: false,
	showing_reblogs: false,
	endorsed: false
	}

	assert expected ==
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent a relationship for the blocking and blocked user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, _subscription} = User.subscribe(user, other_user)
	{:ok, _user_relationship} = User.block(user, other_user)
	{:ok, _user_relationship} = User.block(other_user, user)

	expected = %{
	id: to_string(other_user.id),
	following: false,
	followed_by: false,
	blocking: true,
	blocked_by: 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 a relationship for the user blocking a domain" do
	user = insert(:user)
	other_user = insert(:user, ap_id: "https://bad.site/users/other_user")

	{:ok, user} = User.block_domain(user, "bad.site")

	assert %{domain_blocking: true, blocking: false} =
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent a relationship for the user with a pending follow request" do
	user = insert(:user)
	other_user = insert(:user, locked: true)

	{:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	expected = %{
	id: to_string(other_user.id),
	following: false,
	followed_by: false,
	blocking: false,
	blocked_by: false,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	requested: true,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	assert expected ==
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end
	end

	test "represent an embedded relationship" do
	user =
	insert(:user, %{
	follower_count: 0,
	note_count: 5,
	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, _user_relationship} = 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: user.bio,
	sensitive: false,
	pleroma: %{
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{
	id: to_string(user.id),
	following: false,
	followed_by: false,
	blocking: true,
	blocked_by: false,
	subscribing: false,
	muting: false,
	muting_notifications: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	},
	skip_thread_containment: false
	}
	}

	assert expected ==
	AccountView.render("show.json", %{user: refresh_record(user), for: other_user})
	end

	test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
	user = insert(:user, pleroma_settings_store: %{fe: "test"})

	result =
	AccountView.render("show.json", %{user: user, for: user, with_pleroma_settings: true})

	assert result.pleroma.settings_store == %{:fe => "test"}

	result = AccountView.render("show.json", %{user: user, with_pleroma_settings: true})
	assert result.pleroma[:settings_store] == nil

	result = AccountView.render("show.json", %{user: user, for: user})
	assert result.pleroma[:settings_store] == nil
	end

	test "sanitizes display names" do
	user = insert(:user, name: "<marquee> username </marquee>")
	result = AccountView.render("show.json", %{user: user})
	refute result.display_name == "<marquee> username </marquee>"
	end

	test "never display nil user follow counts" do
	user = insert(:user, following_count: 0, follower_count: 0)
	result = AccountView.render("show.json", %{user: user})

	assert result.following_count == 0
	assert result.followers_count == 0
	end

	describe "hiding follows/following" do
	test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do
	user =
	insert(:user, %{
	hide_followers: true,
	hide_followers_count: true,
	hide_follows: true,
	hide_follows_count: true
	})

	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 0,
	following_count: 0,
	pleroma: %{hide_follows_count: true, hide_followers_count: true}
	} = AccountView.render("show.json", %{user: user})
	end

	test "shows when follows/followers are hidden" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1,
	pleroma: %{hide_follows: true, hide_followers: true}
	} = AccountView.render("show.json", %{user: user})
	end

	test "shows actual follower/following count to the account owner" do
	user = insert(:user, hide_followers: true, hide_follows: true)
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows unread_conversation_count only to the account owner" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} =
	CommonAPI.post(other_user, %{
	"status" => "Hey @#{user.nickname}.",
	"visibility" => "direct"
	})

	user = User.get_cached_by_ap_id(user.ap_id)

	assert AccountView.render("show.json", %{user: user, for: other_user})[:pleroma][
	:unread_conversation_count
	] == nil

	assert AccountView.render("show.json", %{user: user, for: user})[:pleroma][
	:unread_conversation_count
	] == 1
	end
	end

	describe "follow requests counter" do
	test "shows zero when no follow requests are pending" do
	user = insert(:user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when follow requests are pending" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when accepting a follow request" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.accept_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when rejecting a follow request" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.reject_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when historical unapproved requests are present" do
	user = insert(:user, locked: true)

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	{:ok, user} = User.update_and_set_cache(user, %{locked: false})

	assert %{locked: false, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end
	end
	end
	diff --git a/test/web/push/impl_test.exs b/test/web/push/impl_test.exs
	index 9b554601d..acae7a734 100644
	--- a/test/web/push/impl_test.exs
	+++ b/test/web/push/impl_test.exs
	@@ -1,185 +1,232 @@
	# 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.ImplTest do
	use Pleroma.DataCase

	alias Pleroma.Object
	+ alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	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}}
	)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "<Lorem ipsum dolor sit amet."})

	notif =
	insert(:notification,
	user: user,
	activity: activity
	)

	assert Impl.perform(notif) == [:ok, :ok]
	end

	@tag capture_log: true
	test "returns error if notif does not match " do
	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 subscription if result 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 title and body for create activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	object = Object.normalize(activity)

	assert Impl.format_body(
	%{
	activity: activity
	},
	user,
	object
	) ==
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	assert Impl.format_title(%{activity: activity}) ==
	"New Mention"
	end

	test "renders title and body for follow activity" do
	user = insert(:user, nickname: "Bob")
	other_user = insert(:user)
	{:ok, _, _, activity} = CommonAPI.follow(user, other_user)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: activity}, user, object) == "@Bob has followed you"

	assert Impl.format_title(%{activity: activity}) ==
	"New Follower"
	end

	test "renders title and body for announce activity" do
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, announce_activity, _} = CommonAPI.repeat(activity.id, user)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: announce_activity}, user, object) ==
	"@#{user.nickname} repeated: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	assert Impl.format_title(%{activity: announce_activity}) ==
	"New Repeat"
	end

	test "renders title and body for like activity" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" =>
	"<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	})

	{:ok, activity, _} = CommonAPI.favorite(activity.id, user)
	object = Object.normalize(activity)

	assert Impl.format_body(%{activity: activity}, user, object) == "@Bob has favorited your post"

	assert Impl.format_title(%{activity: activity}) ==
	"New Favorite"
	end

	test "renders title for create activity with direct visibility" do
	user = insert(:user, nickname: "Bob")

	{:ok, activity} =
	CommonAPI.post(user, %{
	"visibility" => "direct",
	"status" => "This is just between you and me, pal"
	})

	assert Impl.format_title(%{activity: activity}) ==
	"New Direct Message"
	end
	+
	+ describe "build_content/3" do
	+ test "returns info content for direct message with enabled privacy option" do
	+ user = insert(:user, nickname: "Bob")
	+ user2 = insert(:user, nickname: "Rob", notification_settings: %{privacy_option: true})
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ "visibility" => "direct",
	+ "status" => "<Lorem ipsum dolor sit amet."
	+ })
	+
	+ notif = insert(:notification, user: user2, activity: activity)
	+
	+ actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	+ object = Object.normalize(activity)
	+
	+ assert Impl.build_content(notif, actor, object) == %{
	+ body: "@Bob",
	+ title: "New Direct Message"
	+ }
	+ end
	+
	+ test "returns regular content for direct message with disabled privacy option" do
	+ user = insert(:user, nickname: "Bob")
	+ user2 = insert(:user, nickname: "Rob", notification_settings: %{privacy_option: false})
	+
	+ {:ok, activity} =
	+ CommonAPI.post(user, %{
	+ "visibility" => "direct",
	+ "status" =>
	+ "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	+ })
	+
	+ notif = insert(:notification, user: user2, activity: activity)
	+
	+ actor = User.get_cached_by_ap_id(notif.activity.data["actor"])
	+ object = Object.normalize(activity)
	+
	+ assert Impl.build_content(notif, actor, object) == %{
	+ body:
	+ "@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini...",
	+ title: "New Direct Message"
	+ }
	+ end
	+ end
	end
	diff --git a/test/web/twitter_api/util_controller_test.exs b/test/web/twitter_api/util_controller_test.exs
	index 986ee01f3..734cd2211 100644
	--- a/test/web/twitter_api/util_controller_test.exs
	+++ b/test/web/twitter_api/util_controller_test.exs
	@@ -1,885 +1,905 @@
	# 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.UtilControllerTest do
	use Pleroma.Web.ConnCase
	use Oban.Testing, repo: Pleroma.Repo

	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	import ExUnit.CaptureLog
	import Pleroma.Factory
	import Mock

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

	clear_config([:instance])
	clear_config([:frontend_configurations, :pleroma_fe])
	clear_config([:user, :deny_follow_blocked])

	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 "it imports follow lists from file", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)

	with_mocks([
	{File, [],
	read!: fn "follow_list.txt" ->
	"Account address,Show boosts\n#{user2.ap_id},true"
	end}
	]) do
	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/follow_import", %{"list" => %Plug.Upload{path: "follow_list.txt"}})
	\|> json_response(:ok)

	assert response == "job started"

	assert ObanHelpers.member?(
	%{
	"op" => "follow_import",
	"follower_id" => user1.id,
	"followed_identifiers" => [user2.ap_id]
	},
	all_enqueued(worker: Pleroma.Workers.BackgroundWorker)
	)
	end
	end

	test "it imports new-style mastodon follow lists", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/follow_import", %{
	"list" => "Account address,Show boosts\n#{user2.ap_id},true"
	})
	\|> json_response(:ok)

	assert response == "job started"
	end

	test "requires 'follow' or 'write:follows' permissions", %{conn: conn} do
	token1 = insert(:oauth_token, scopes: ["read", "write"])
	token2 = insert(:oauth_token, scopes: ["follow"])
	token3 = insert(:oauth_token, scopes: ["something"])
	another_user = insert(:user)

	for token <- [token1, token2, token3] do
	conn =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> post("/api/pleroma/follow_import", %{"list" => "#{another_user.ap_id}"})

	if token == token3 do
	assert %{"error" => "Insufficient permissions: follow \| write:follows."} ==
	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

	test "it imports blocks users from file", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	with_mocks([
	{File, [], read!: fn "blocks_list.txt" -> "#{user2.ap_id} #{user3.ap_id}" end}
	]) do
	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/pleroma/blocks_import", %{"list" => %Plug.Upload{path: "blocks_list.txt"}})
	\|> json_response(:ok)

	assert response == "job started"

	assert ObanHelpers.member?(
	%{
	"op" => "blocks_import",
	"blocker_id" => user1.id,
	"blocked_identifiers" => [user2.ap_id, user3.ap_id]
	},
	all_enqueued(worker: Pleroma.Workers.BackgroundWorker)
	)
	end
	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", %{
	"followers" => false,
	"bar" => 1
	})
	\|> json_response(:ok)

	user = Repo.get(User, user.id)

	- assert %{
	- "followers" => false,
	- "follows" => true,
	- "non_follows" => true,
	- "non_followers" => true
	+ assert %Pleroma.User.NotificationSetting{
	+ followers: false,
	+ follows: true,
	+ non_follows: true,
	+ non_followers: true,
	+ privacy_option: false
	+ } == user.notification_settings
	+ end
	+
	+ test "it update notificatin privacy option", %{conn: conn} do
	+ user = insert(:user)
	+
	+ conn
	+ \|> assign(:user, user)
	+ \|> put("/api/pleroma/notification_settings", %{"privacy_option" => "1"})
	+ \|> json_response(:ok)
	+
	+ user = refresh_record(user)
	+
	+ assert %Pleroma.User.NotificationSetting{
	+ followers: true,
	+ follows: true,
	+ non_follows: true,
	+ non_followers: true,
	+ privacy_option: true
	} == user.notification_settings
	end
	end

	describe "GET /api/statusnet/config" do
	test "it returns config in xml format", %{conn: conn} do
	instance = Pleroma.Config.get(:instance)

	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/api/statusnet/config")
	\|> response(:ok)

	assert response ==
	"<config>\n<site>\n<name>#{Keyword.get(instance, :name)}</name>\n<site>#{
	Pleroma.Web.base_url()
	}</site>\n<textlimit>#{Keyword.get(instance, :limit)}</textlimit>\n<closed>#{
	!Keyword.get(instance, :registrations_open)
	}</closed>\n</site>\n</config>\n"
	end

	test "it returns config in json format", %{conn: conn} do
	instance = Pleroma.Config.get(:instance)
	Pleroma.Config.put([:instance, :managed_config], true)
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], true)
	Pleroma.Config.put([:instance, :public], false)
	Pleroma.Config.put([:frontend_configurations, :pleroma_fe], %{theme: "asuka-hospital"})

	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/api/statusnet/config")
	\|> json_response(:ok)

	expected_data = %{
	"site" => %{
	"accountActivationRequired" => "0",
	"closed" => "1",
	"description" => Keyword.get(instance, :description),
	"invitesEnabled" => "1",
	"name" => Keyword.get(instance, :name),
	"pleromafe" => %{"theme" => "asuka-hospital"},
	"private" => "1",
	"safeDMMentionsEnabled" => "0",
	"server" => Pleroma.Web.base_url(),
	"textlimit" => to_string(Keyword.get(instance, :limit)),
	"uploadlimit" => %{
	"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)),
	"uploadlimit" => to_string(Keyword.get(instance, :upload_limit))
	},
	"vapidPublicKey" => Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
	}
	}

	assert response == expected_data
	end

	test "returns the state of safe_dm_mentions flag", %{conn: conn} do
	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"
	end

	test "it returns the managed config", %{conn: conn} do
	Pleroma.Config.put([:instance, :managed_config], false)
	Pleroma.Config.put([:frontend_configurations, :pleroma_fe], %{theme: "asuka-hospital"})

	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"] == %{"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 =
	conn
	\|> get("/api/pleroma/emoji")
	\|> json_response(200)

	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 - remote_follow/2" 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

	test "show follow page if the `acct` is a account link", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/ostatus_subscribe?acct=https://mastodon.social/users/emelie")

	assert html_response(response, 200) =~ "Remote follow"
	end

	test "show follow page with error when user cannot fecth by `acct` link", %{conn: conn} do
	user = insert(:user)

	assert capture_log(fn ->
	response =
	conn
	\|> assign(:user, user)
	\|> get("/ostatus_subscribe?acct=https://mastodon.social/users/not_found")

	assert html_response(response, 200) =~ "Error fetching user"
	end) =~ "Object has been deleted"
	end
	end

	describe "POST /ostatus_subscribe - do_remote_follow/2 with assigned user " do
	test "follows user", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post("/ostatus_subscribe", %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Account followed!"
	assert user2.follower_address in User.following(user)
	end

	test "returns error when user is deactivated", %{conn: conn} do
	user = insert(:user, deactivated: true)
	user2 = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post("/ostatus_subscribe", %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when user is blocked", %{conn: conn} do
	Pleroma.Config.put([:user, :deny_follow_blocked], true)
	user = insert(:user)
	user2 = insert(:user)

	{:ok, _user_block} = Pleroma.User.block(user2, user)

	response =
	conn
	\|> assign(:user, user)
	\|> post("/ostatus_subscribe", %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when followee not found", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post("/ostatus_subscribe", %{"user" => %{"id" => "jimm"}})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns success result when user already in followers", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)
	{:ok, _, _, _} = CommonAPI.follow(user, user2)

	response =
	conn
	\|> assign(:user, refresh_record(user))
	\|> post("/ostatus_subscribe", %{"user" => %{"id" => user2.id}})
	\|> response(200)

	assert response =~ "Account followed!"
	end
	end

	describe "POST /ostatus_subscribe - do_remote_follow/2 without assigned user " do
	test "follows", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> post("/ostatus_subscribe", %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Account followed!"
	assert user2.follower_address in User.following(user)
	end

	test "returns error when followee not found", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/ostatus_subscribe", %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => "jimm"}
	})
	\|> response(200)

	assert response =~ "Error following account"
	end

	test "returns error when login invalid", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/ostatus_subscribe", %{
	"authorization" => %{"name" => "jimm", "password" => "test", "id" => user.id}
	})
	\|> response(200)

	assert response =~ "Wrong username or password"
	end

	test "returns error when password invalid", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	response =
	conn
	\|> post("/ostatus_subscribe", %{
	"authorization" => %{"name" => user.nickname, "password" => "42", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Wrong username or password"
	end

	test "returns error when user is blocked", %{conn: conn} do
	Pleroma.Config.put([:user, :deny_follow_blocked], true)
	user = insert(:user)
	user2 = insert(:user)
	{:ok, _user_block} = Pleroma.User.block(user2, user)

	response =
	conn
	\|> post("/ostatus_subscribe", %{
	"authorization" => %{"name" => user.nickname, "password" => "test", "id" => user2.id}
	})
	\|> response(200)

	assert response =~ "Error following account"
	end
	end

	describe "GET /api/pleroma/healthcheck" do
	clear_config([:instance, :healthcheck])

	test "returns 503 when healthcheck disabled", %{conn: conn} do
	Pleroma.Config.put([:instance, :healthcheck], false)

	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response(503)

	assert response == %{}
	end

	test "returns 200 when healthcheck enabled and all ok", %{conn: conn} do
	Pleroma.Config.put([:instance, :healthcheck], true)

	with_mock Pleroma.Healthcheck,
	system_info: fn -> %Pleroma.Healthcheck{healthy: true} end do
	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response(200)

	assert %{
	"active" => _,
	"healthy" => true,
	"idle" => _,
	"memory_used" => _,
	"pool_size" => _
	} = response
	end
	end

	test "returns 503 when healthcheck enabled and health is false", %{conn: conn} do
	Pleroma.Config.put([:instance, :healthcheck], true)

	with_mock Pleroma.Healthcheck,
	system_info: fn -> %Pleroma.Healthcheck{healthy: false} end do
	response =
	conn
	\|> get("/api/pleroma/healthcheck")
	\|> json_response(503)

	assert %{
	"active" => _,
	"healthy" => false,
	"idle" => _,
	"memory_used" => _,
	"pool_size" => _
	} = response
	end
	end
	end

	describe "POST /api/pleroma/disable_account" do
	test "it returns HTTP 200", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/disable_account", %{"password" => "test"})
	\|> json_response(:ok)

	assert response == %{"status" => "success"}
	ObanHelpers.perform_all()

	user = User.get_cached_by_id(user.id)

	assert user.deactivated == true
	end

	test "it returns returns when password invalid", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/disable_account", %{"password" => "test1"})
	\|> json_response(:ok)

	assert response == %{"error" => "Invalid password."}
	user = User.get_cached_by_id(user.id)

	refute user.deactivated
	end
	end

	describe "GET /api/statusnet/version" do
	test "it returns version in xml format", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/xml")
	\|> get("/api/statusnet/version")
	\|> response(:ok)

	assert response == "<version>#{Pleroma.Application.named_version()}</version>"
	end

	test "it returns version in json format", %{conn: conn} do
	response =
	conn
	\|> put_req_header("accept", "application/json")
	\|> get("/api/statusnet/version")
	\|> json_response(:ok)

	assert response == "#{Pleroma.Application.named_version()}"
	end
	end

	describe "POST /main/ostatus - remote_subscribe/2" do
	test "renders subscribe form", %{conn: conn} do
	user = insert(:user)

	response =
	conn
	\|> post("/main/ostatus", %{"nickname" => user.nickname, "profile" => ""})
	\|> response(:ok)

	refute response =~ "Could not find user"
	assert response =~ "Remotely follow #{user.nickname}"
	end

	test "renders subscribe form with error when user not found", %{conn: conn} do
	response =
	conn
	\|> post("/main/ostatus", %{"nickname" => "nickname", "profile" => ""})
	\|> response(:ok)

	assert response =~ "Could not find user"
	refute response =~ "Remotely follow"
	end

	test "it redirect to webfinger url", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	conn =
	conn
	\|> post("/main/ostatus", %{
	"user" => %{"nickname" => user.nickname, "profile" => user2.ap_id}
	})

	assert redirected_to(conn) ==
	"https://social.heldscal.la/main/ostatussub?profile=#{user.ap_id}"
	end

	test "it renders form with error when use not found", %{conn: conn} do
	user2 = insert(:user, ap_id: "shp@social.heldscal.la")

	response =
	conn
	\|> post("/main/ostatus", %{"user" => %{"nickname" => "jimm", "profile" => user2.ap_id}})
	\|> response(:ok)

	assert response =~ "Something went wrong."
	end
	end

	test "it returns new captcha", %{conn: conn} do
	with_mock Pleroma.Captcha,
	new: fn -> "test_captcha" end do
	resp =
	conn
	\|> get("/api/pleroma/captcha")
	\|> response(200)

	assert resp == "\"test_captcha\""
	assert called(Pleroma.Captcha.new())
	end
	end

	defp with_credentials(conn, username, password) do
	header_content = "Basic " <> Base.encode64("#{username}:#{password}")
	put_req_header(conn, "authorization", header_content)
	end

	defp valid_user(_context) do
	user = insert(:user)
	[user: user]
	end

	describe "POST /api/pleroma/change_email" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/change_email")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_email", %{
	"password" => "hi",
	"email" => "test@test.com"
	})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials, valid password and invalid email", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_email", %{
	"password" => "test",
	"email" => "foobar"
	})

	assert json_response(conn, 200) == %{"error" => "Email has invalid format."}
	end

	test "with credentials, valid password and no email", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_email", %{
	"password" => "test"
	})

	assert json_response(conn, 200) == %{"error" => "Email can't be blank."}
	end

	test "with credentials, valid password and blank email", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_email", %{
	"password" => "test",
	"email" => ""
	})

	assert json_response(conn, 200) == %{"error" => "Email can't be blank."}
	end

	test "with credentials, valid password and non unique email", %{
	conn: conn,
	user: current_user
	} do
	user = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_email", %{
	"password" => "test",
	"email" => user.email
	})

	assert json_response(conn, 200) == %{"error" => "Email has already been taken."}
	end

	test "with credentials, valid password and valid email", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_email", %{
	"password" => "test",
	"email" => "cofe@foobar.com"
	})

	assert json_response(conn, 200) == %{"status" => "success"}
	end
	end

	describe "POST /api/pleroma/change_password" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/change_password")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials, valid password and new password and confirmation not matching", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "notnewpass"
	})

	assert json_response(conn, 200) == %{
	"error" => "New password does not match confirmation."
	}
	end

	test "with credentials, valid password and invalid new password", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "",
	"new_password_confirmation" => ""
	})

	assert json_response(conn, 200) == %{
	"error" => "New password can't be blank."
	}
	end

	test "with credentials, valid password and matching new password and confirmation", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"status" => "success"}
	fetched_user = User.get_cached_by_id(current_user.id)
	assert Comeonin.Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
	end
	end

	describe "POST /api/pleroma/delete_account" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/delete_account")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "hi"})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials and valid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "test"})

	assert json_response(conn, 200) == %{"status" => "success"}
	# Wait a second for the started task to end
	:timer.sleep(1000)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 2:22 AM (21 h, 29 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768664
Default Alt Text: (314 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions