No OneTemporary
Actions

Size

107 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/admin-report-notification-type.change b/changelog.d/admin-report-notification-type.change
	new file mode 100644
	index 000000000..6899a131f
	--- /dev/null
	+++ b/changelog.d/admin-report-notification-type.change
	@@ -0,0 +1 @@
	+Use `admin.report` for report notification type
	\ No newline at end of file
	diff --git a/docs/development/API/differences_in_mastoapi_responses.md b/docs/development/API/differences_in_mastoapi_responses.md
	index 4326c4255..24fe25b8c 100644
	--- a/docs/development/API/differences_in_mastoapi_responses.md
	+++ b/docs/development/API/differences_in_mastoapi_responses.md
	@@ -1,523 +1,514 @@
	# 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` and `/api/v2/instance`

	## Flake IDs

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

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

	Adding the parameter `reply_visibility` to the public and home timelines queries will filter replies. Possible values: without parameter (default) shows all replies, `following` - replies directed to you or users you follow, `self` - replies directed to you.

	Adding the parameter `instance=lain.com` to the public timeline will show only statuses originating from `lain.com` (or any remote instance).

	Home, public, hashtag & list timelines accept these parameters:

	- `only_media`: show only statuses with media attached
	- `local`: show only local statuses
	- `remote`: show only remote statuses

	## Statuses

	- `visibility`: has additional possible values `list` and `local` (for local-only statuses)

	Has these additional fields under the `pleroma` object:

	- `local`: true if the post was made on the local instance
	- `conversation_id`: the ID of the 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 its 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 its 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
	- `emoji_reactions`: A list with emoji / reaction maps. The format is `{name: "☕", count: 1, me: true}`. Contains no information about the reacting users, for that use the `/statuses/:id/reactions` endpoint.
	- `parent_visible`: If the parent of this post is visible to the user or not.
	- `pinned_at`: a datetime (iso8601) when status was pinned, `null` otherwise.
	- `quotes_count`: the count of status quotes.
	- `non_anonymous`: true if the source post specifies the poll results are not anonymous. Currently only implemented by Smithereen.
	- `bookmark_folder`: the ID of the folder bookmark is stored within (if any).
	- `list_id`: the ID of the list the post is addressed to (if any, only returned to author).

	The `GET /api/v1/statuses/:id/source` endpoint additionally has the following attributes:

	- `content_type`: The content type of the status source.

	## Scheduled statuses

	Has these additional fields in `params`:

	- `expires_in`: the number of seconds the posted activity should expire in.

	## Media Attachments

	Has these additional fields under the `pleroma` object:

	- `mime_type`: mime type of the attachment.

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

	### Limitations

	Pleroma does not process remote images and therefore cannot include fields such as `meta` and `blurhash`. It does not support focal points or aspect ratios. The frontend is expected to handle it.

	## Bookmarks

	The `GET /api/v1/bookmarks` endpoint accepts optional parameter `folder_id` for bookmark folder ID.

	The `POST /api/v1/statuses/:id/bookmark` endpoint accepts optional parameter `folder_id` for bookmark folder ID.

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

	`/api/v1/accounts/:id/statuses` endpoint accepts these parameters:

	- `pinned`: include only pinned statuses
	- `tagged`: with tag
	- `only_media`: include only statuses with media attached
	- `with_muted`: include statuses/reactions from muted accounts
	- `exclude_reblogs`: exclude reblogs
	- `only_reblogs`: include only reblogs
	- `exclude_replies`: exclude replies
	- `exclude_visibilities`: exclude visibilities

	Endpoints which accept `with_relationships` parameter:

	- `/api/v1/accounts/:id`
	- `/api/v1/accounts/:id/followers`
	- `/api/v1/accounts/:id/following`
	- `/api/v1/mutes`

	Has these additional fields under the `pleroma` object:

	- `ap_id`: nullable URL string, ActivityPub id of the user
	- `background_image`: nullable URL string, background image of the user
	- `tags`: Lists an array of tags for the user
	- `relationship` (object): Includes fields as documented for Mastodon API https://docs.joinmastodon.org/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_favorites`: boolean, true when the user has hiding favorites enabled
	- `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 `/api/v1/accounts/verify_credentials` and `/api/v1/accounts/update_credentials`
	- `chat_token`: The token needed for Pleroma shoutbox. Only returned in `/api/v1/accounts/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.
	- `unread_notifications_count`: The count of unread notifications. Only returned to the account owner.
	- `notification_settings`: object, can be absent. See `/api/v1/pleroma/notification_settings` for the parameters/keys returned.
	- `accepts_chat_messages`: boolean, but can be null if we don't have that information about a user
	- `favicon`: nullable URL string, Favicon image of the user's instance
	- `avatar_description`: string, image description for user avatar, defaults to empty string
	- `header_description`: string, image description for user banner, defaults to empty string

	### 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
	- `discoverable`: boolean, true when the user allows external services (search bots) etc. to index / list the account (regardless of this setting, user will still appear in regular search results)
	- `actor_type`: string, the type of this account.

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

	## Search (global)

	Unlisted posts are available in search results, they are considered to be public posts that shouldn't be shown in local/federated timeline.

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

	### EmojiReact Notification

	The `type` value is `pleroma:emoji_reaction`. Has these fields:

	- `emoji`: The used emoji
	- `account`: The account of the user who reacted
	- `status`: The status that was reacted on

	### ChatMention Notification (not default)

	This notification has to be requested explicitly.

	The `type` value is `pleroma:chat_mention`

	- `account`: The account who sent the message
	- `chat_message`: The chat message

	-### Report Notification (not default)
	-
	-This notification has to be requested explicitly.
	-
	-The `type` value is `pleroma:report`
	-
	-- `account`: The account who reported
	-- `report`: The report
	-
	## 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`.
	-- `include_types`: will include the notifications for activities with the given types. The parameter accepts an array of types (`mention`, `follow`, `reblog`, `favourite`, `move`, `pleroma:emoji_reaction`, `pleroma:chat_mention`, `pleroma:report`). Usage example: `GET /api/v1/notifications?include_types[]=mention&include_types[]=reblog`.
	+- `include_types`: will include the notifications for activities with the given types. The parameter accepts an array of types (`mention`, `follow`, `reblog`, `favourite`, `move`, `pleroma:emoji_reaction`, `pleroma:chat_mention`, `admin.report`). Usage example: `GET /api/v1/notifications?include_types[]=mention&include_types[]=reblog`.

	## DELETE `/api/v1/notifications/destroy_multiple`

	An endpoint to delete multiple statuses by IDs.

	Required parameters:

	- `ids`: array of activity ids

	Usage example: `DELETE /api/v1/notifications/destroy_multiple/?ids[]=1&ids[]=2`.

	Returns on success: 200 OK `{}`

	## 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 entity 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 post visibility are not affected by this and will still apply.
	- `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted`, `local` 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/accounts/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
	- `also_known_as` - array of ActivityPub IDs, needed for following move
	- `pleroma_background_image` - sets the background image of the user. Can be set to "" (an empty string) to reset.
	- `discoverable` - if true, external services (search bots) etc. are allowed to index / list the account (regardless of this setting, user will still appear in regular search results).
	- `actor_type` - the type of this account.
	- `accepts_chat_messages` - if false, this account will reject all chat messages.
	- `language` - user's preferred language for receiving emails (digest, confirmation, etc.)
	- `avatar_description` - image description for user avatar
	- `header_description` - image description for user banner

	All images (avatar, banner and background) can be reset to the default by sending an empty string ("") instead of a file.

	### 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 `/api/v1/accounts/verify_credentials` endpoint.

	## Authentication

	Pleroma supports refreshing tokens.

	### POST `/oauth/token`

	You can obtain access tokens for a user in a few additional ways.

	#### Refreshing a token

	To obtain a new access token from a refresh token, pass `grant_type=refresh_token` with the following extra parameters:

	- `refresh_token`: The refresh token.

	#### Getting a token with a password

	To obtain a token from a user's password, pass `grant_type=password` with the following extra parameters:

	- `username`: Username to authenticate.
	- `password`: The user's password.

	#### Response body

	Additional fields are returned in the response:

	- `id`: The primary key of this token in Pleroma's database.
	- `me` (user tokens only): The ActivityPub ID of the user who owns the token.

	## Account Registration

	`POST /api/v1/accounts`

	Has these additional 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
	- `captcha_answer_data`: optional, contains provider-specific captcha data
	- `token`: invite token required when the registrations aren't public.
	- `language`: optional, user's preferred language for receiving emails (digest, confirmation, etc.), default to the language set in the `userLanguage` cookies or `Accept-Language` header.

	## Instance

	`GET /api/v1/instance` has additional fields

	- `max_toot_chars`: The maximum characters per post
	- `max_media_attachments`: Maximum number of post media attachments
	- `chat_limit`: The maximum characters per chat message
	- `description_limit`: The maximum characters per image description
	- `poll_limits`: The limits of polls
	- `shout_limit`: The maximum characters per Shoutbox message
	- `upload_limit`: The maximum upload file size
	- `avatar_upload_limit`: The same for avatars
	- `background_upload_limit`: The same for backgrounds
	- `banner_upload_limit`: The same for banners
	- `background_image`: A background image that frontends can use
	- `pleroma.metadata.account_activation_required`: Whether users are required to confirm their emails before signing in
	- `pleroma.metadata.birthday_required`: Whether users are required to provide their birth day when signing in
	- `pleroma.metadata.birthday_min_age`: The minimum user age (in days)
	- `pleroma.metadata.features`: A list of supported features
	- `pleroma.metadata.federation`: The federation restrictions of this instance
	- `pleroma.metadata.fields_limits`: A list of values detailing the length and count limitation for various instance-configurable fields.
	- `pleroma.metadata.post_formats`: A list of the allowed post format types
	- `pleroma.stats.mau`: Monthly active user count
	- `pleroma.vapid_public_key`: The public key needed for push messages

	In, `GET /api/v2/instance` Pleroma-specific fields are all moved into `pleroma` object. `max_toot_chars`, `poll_limits` and `upload_limit` are replaced with their MastoAPI counterparts.

	## Push Subscription

	`POST /api/v1/push/subscription`
	`PUT /api/v1/push/subscription`

	Permits these additional alert types:

	- pleroma:chat_mention
	- pleroma:emoji_reaction

	## Markers

	Has these additional fields under the `pleroma` object:

	- `unread_count`: contains number unread notifications

	## Streaming

	### Chats

	There is an additional `user:pleroma_chat` stream. Incoming chat messages will make the current chat be sent to this `user` stream. The `event` of an incoming chat message is `pleroma:chat_update`. The payload is the updated chat with the incoming chat message in the `last_message` field.

	### Remote timelines

	For viewing remote server timelines, there are `public:remote` and `public:remote:media` streams. Each of these accept a parameter like `?instance=lain.com`.

	### Follow relationships updates

	Pleroma streams follow relationships updates as `pleroma:follow_relationships_update` events to the `user` stream.

	The message payload consist of:

	- `state`: a relationship state, one of `follow_pending`, `follow_accept` or `follow_reject`.

	- `follower` and `following` maps with following fields:
	- `id`: user ID
	- `follower_count`: follower count
	- `following_count`: following count

	### Authenticating via `sec-websocket-protocol` header

	Pleroma allows to authenticate via the `sec-websocket-protocol` header, for example, if your access token is `your-access-token`, you can authenticate using the following:

	```
	sec-websocket-protocol: your-access-token
	```

	### Authenticating after connection via `pleroma:authenticate` event

	Pleroma allows to authenticate after connection is established, via the `pleroma:authenticate` event. For example, if your access token is `your-access-token`, you can send the following after the connection is established:

	```
	{"type": "pleroma:authenticate", "token": "your-access-token"}
	```

	### Response to client-sent events

	Pleroma will respond to client-sent events that it recognizes. Supported event types are:

	- `subscribe`
	- `unsubscribe`
	- `pleroma:authenticate`

	The reply will be in the following format:

	```
	{
	"event": "pleroma:respond",
	"payload": "{\"type\": \"<type of the client-sent event>\", \"result\": \"<result of the action>\", \"error\": \"<error code>\"}"
	}
	```

	Result of the action can be either `success`, `ignored` or `error`. If it is `error`, the `error` property will contain the error code. Otherwise, the `error` property will not be present. Below are some examples:

	```
	{
	"event": "pleroma:respond",
	"payload": "{\"type\": \"pleroma:authenticate\", \"result\": \"success\"}"
	}

	{
	"event": "pleroma:respond",
	"payload": "{\"type\": \"subscribe\", \"result\": \"ignored\"}"
	}

	{
	"event": "pleroma:respond",
	"payload": "{\"type\": \"unsubscribe\", \"result\": \"error\", \"error\": \"bad_topic\"}"
	}
	```

	If the sent event is not of a type that Pleroma supports, it will not reply.

	### The `stream` attribute of a server-sent event

	Technically, this is in Mastodon, but its documentation does nothing to specify its format.

	This attribute appears on every event type except `pleroma:respond` and `delete`. It helps clients determine where they should display the new statuses.

	The value of the attribute is an array containing one or two elements. The first element is the type of the stream. The second is the identifier related to that specific stream, if applicable.

	For the following stream types, there is a second element in the array:

	- `list`: The second element is the id of the list, as a string.
	- `hashtag`: The second element is the name of the hashtag.
	- `public:remote:media` and `public:remote`: The second element is the domain of the corresponding instance.

	For all other stream types, there is no second element.

	Some examples of valid `stream` values:

	- `["list", "1"]`: List of id 1.
	- `["hashtag", "mew"]`: The hashtag #mew.
	- `["user:notifications"]`: Notifications for the current user.
	- `["user"]`: Home timeline.
	- `["public:remote", "mew.moe"]`: Public posts from the instance mew.moe .

	### The unified streaming endpoint

	If you do not specify a stream to connect to when requesting `/api/v1/streaming`, you will enter a connection that subscribes to no streams. After the connection is established, you can authenticate and then subscribe to different streams.

	### List of supported streams

	Below is a list of supported streams by Pleroma. To make a single-stream WebSocket connection, append the string specified in "Query style" to the streaming endpoint url.
	To subscribe to a stream after the connection is established, merge the JSON object specified in "Subscribe style" with `{"type": "subscribe"}`. To unsubscribe, merge it with `{"type": "unsubscribe"}`.

	For example, to receive updates on the list 1, you can connect to `/api/v1/streaming/?stream=list&list=1`, or send

	```
	{"type": "subscribe", "stream": "list", "list": "1"}
	```

	upon establishing the websocket connection.

	To unsubscribe to list 1, send

	```
	{"type": "unsubscribe", "stream": "list", "list": "1"}
	```

	Note that if you specify a stream that requires a logged-in user in the query string (for example, `user` or `list`), you have to specify the access token when you are trying to establish the connection, i.e. in the query string or via the `sec-websocket-protocol` header.

	- `list`
	- Query style: `?stream=list&list=<id>`
	- Subscribe style: `{"stream": "list", "list": "<id>"}`
	- `public`, `public:local`, `public:media`, `public:local:media`, `user`, `user:pleroma_chat`, `user:notifications`, `direct`
	- Query style: `?stream=<stream name>`
	- Subscribe style: `{"stream": "<stream name>"}`
	- `hashtag`
	- Query style: `?stream=hashtag&tag=<name>`
	- Subscribe style: `{"stream": "hashtag", "tag": "<name>"}`
	- `public:remote`, `public:remote:media`
	- Query style: `?stream=<stream name>&instance=<instance domain>`
	- Subscribe style: `{"stream": "<stream name>", "instance": "<instance domain>"}`

	## User muting and thread muting

	Both user muting and thread muting can be done for only a certain time by adding an `expires_in` parameter to the API calls and giving the expiration time in seconds.

	## Not implemented

	Pleroma is generally compatible with the Mastodon 2.7.2 API, but some newer features and non-essential features are omitted. These features usually return an HTTP 200 status code, but with an empty response. While they may be added in the future, they are considered low priority.

	### Suggestions

	Added in Mastodon 2.4.3

	- `GET /api/v1/suggestions`: Returns an empty array, `[]`

	### Trends

	Added in Mastodon 3.0.0

	- `GET /api/v1/trends`: Returns an empty array, `[]`

	### Featured tags

	Added in Mastodon 3.0.0

	- `GET /api/v1/featured_tags`: Returns HTTP 404
	diff --git a/lib/pleroma/notification.ex b/lib/pleroma/notification.ex
	index 75f4ba503..80844ed71 100644
	--- a/lib/pleroma/notification.ex
	+++ b/lib/pleroma/notification.ex
	@@ -1,768 +1,769 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Notification do
	use Ecto.Schema

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.FollowingRelationship
	alias Pleroma.Marker
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	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)
	# This is an enum type in the database. If you add a new notification type,
	# remember to add a migration to add it to the `notifications_type` enum
	# as well.
	field(:type, :string)
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	belongs_to(:activity, Activity, type: FlakeId.Ecto.CompatType)

	timestamps()
	end

	def update_notification_type(user, activity) do
	with %__MODULE__{} = notification <-
	Repo.get_by(__MODULE__, user_id: user.id, activity_id: activity.id) do
	type =
	activity
	\|> type_from_activity()

	notification
	\|> changeset(%{type: type})
	\|> Repo.update()
	end
	end

	@spec unread_notifications_count(User.t()) :: integer()
	def unread_notifications_count(%User{id: user_id}) do
	from(q in __MODULE__,
	where: q.user_id == ^user_id and q.seen == false
	)
	\|> Repo.aggregate(:count, :id)
	end

	@notification_types ~w{
	favourite
	follow
	follow_request
	mention
	move
	pleroma:chat_mention
	pleroma:emoji_reaction
	pleroma:report
	reblog
	poll
	status
	+ update
	}

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

	@spec last_read_query(User.t()) :: Ecto.Queryable.t()
	def last_read_query(user) do
	from(q in Pleroma.Notification,
	where: q.user_id == ^user.id,
	where: q.seen == true,
	select: type(q.id, :string),
	limit: 1,
	order_by: fragment("? desc nulls last", q.id)
	)
	end

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

	preloaded_ap_ids = User.outgoing_relationships_ap_ids(user, ap_id_relationships)

	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)
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> join(:left, [n, a], object in Object,
	on:
	fragment(
	"(?->>'id') = associated_object_id(?)",
	object.data,
	a.data
	)
	)
	\|> join(:inner, [_n, a], u in User, on: u.ap_id == a.actor, as: :user_actor)
	\|> preload([n, a, o], activity: {a, object: o})
	\|> where([user_actor: user_actor], user_actor.is_active)
	\|> exclude_notification_muted(user, exclude_notification_muted_opts)
	\|> exclude_blocked(user, exclude_blocked_opts)
	\|> exclude_blockers(user)
	\|> exclude_filtered(user)
	\|> exclude_visibility(opts)
	end

	# Excludes blocked users and non-followed domain-blocked users
	defp exclude_blocked(query, user, opts) do
	blocked_ap_ids = opts[:blocked_users_ap_ids] \|\| User.blocked_users_ap_ids(user)

	query
	\|> where([..., user_actor: user_actor], user_actor.ap_id not in ^blocked_ap_ids)
	\|> FollowingRelationship.keep_following_or_not_domain_blocked(user)
	end

	defp exclude_blockers(query, user) do
	if Pleroma.Config.get([:activitypub, :blockers_visible]) == true do
	query
	else
	blocker_ap_ids = User.incoming_relationships_ungrouped_ap_ids(user, [:block])

	query
	\|> where([..., user_actor: user_actor], user_actor.ap_id not in ^blocker_ap_ids)
	end
	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([..., user_actor: user_actor], user_actor.ap_id not in ^notification_muted_ap_ids)
	\|> join(:left, [n, a], tm in ThreadMute,
	on: tm.user_id == ^user.id and tm.context == fragment("?->>'context'", a.data),
	as: :thread_mute
	)
	\|> where([thread_mute: thread_mute], is_nil(thread_mute.user_id))
	end

	defp exclude_filtered(query, user) do
	case Pleroma.Filter.compose_regex(user) do
	nil ->
	query

	regex ->
	from([_n, a, o] in query,
	where:
	fragment("not(?->>'content' ~* ?)", o.data, ^regex) or
	fragment("?->>'content' is null", o.data) or
	fragment("?->>'actor' = ?", o.data, ^user.ap_id)
	)
	end
	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(
	"associated_object_id(?)",
	a.data
	) ==
	fragment(
	"associated_object_id(?)",
	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, mutated_activity: mutated_activity],
	not fragment(
	"""
	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
	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,
	# Ideally we would preload object and activities here
	# but Ecto does not support preloads in update_all
	select: n.id
	)

	Multi.new()
	\|> Multi.update_all(:ids, query, set: [seen: true, updated_at: NaiveDateTime.utc_now()])
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()
	end

	@spec read_one(User.t(), String.t()) ::
	{:ok, Notification.t()} \| {:error, Ecto.Changeset.t()} \| nil
	def read_one(%User{} = user, notification_id) do
	with {:ok, %Notification{} = notification} <- get(user, notification_id) do
	Multi.new()
	\|> Multi.update(:update, changeset(notification, %{seen: true}))
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()
	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(%Pleroma.Activity{} = activity) do
	Notification
	\|> where([n], n.activity_id == ^activity.id)
	\|> Repo.delete_all()
	\|> case do
	{_, notifications} -> {:ok, notifications}
	_ -> {:error, "Cannot dismiss notification"}
	end
	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

	@spec create_notifications(Activity.t()) :: {:ok, [Notification.t()] \| []}
	def create_notifications(activity)

	def create_notifications(%Activity{data: %{"to" => _, "type" => "Create"}} = activity) do
	object = Object.normalize(activity, fetch: false)

	if object && object.data["type"] == "Answer" do
	{:ok, []}
	else
	do_create_notifications(activity)
	end
	end

	def create_notifications(%Activity{data: %{"type" => type}} = activity)
	when type in ["Follow", "Like", "Announce", "Move", "EmojiReact", "Flag", "Update"] do
	do_create_notifications(activity)
	end

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

	defp do_create_notifications(%Activity{} = activity) do
	enabled_receivers = get_notified_from_activity(activity)

	enabled_subscribers = get_notified_subscribers_from_activity(activity)

	notifications =
	(Enum.map(enabled_receivers, fn user ->
	create_notification(activity, user)
	end) ++
	Enum.map(enabled_subscribers -- enabled_receivers, fn user ->
	create_notification(activity, user, type: "status")
	end))
	\|> Enum.reject(&is_nil/1)

	{:ok, notifications}
	end

	defp type_from_activity(%{data: %{"type" => type}} = activity) do
	case type do
	"Follow" ->
	if Activity.follow_accepted?(activity) do
	"follow"
	else
	"follow_request"
	end

	"Announce" ->
	"reblog"

	"Like" ->
	"favourite"

	"Move" ->
	"move"

	"EmojiReact" ->
	"pleroma:emoji_reaction"

	"Flag" ->
	"pleroma:report"

	# Compatibility with old reactions
	"EmojiReaction" ->
	"pleroma:emoji_reaction"

	"Create" ->
	activity
	\|> type_from_activity_object()

	"Update" ->
	"update"

	t ->
	raise "No notification type for activity type #{t}"
	end
	end

	defp type_from_activity_object(%{data: %{"type" => "Create", "object" => %{}}}), do: "mention"

	defp type_from_activity_object(%{data: %{"type" => "Create"}} = activity) do
	object = Object.get_by_ap_id(activity.data["object"])

	case object && object.data["type"] do
	"ChatMessage" -> "pleroma:chat_mention"
	_ -> "mention"
	end
	end

	# TODO move to sql, too.
	def create_notification(%Activity{} = activity, %User{} = user, opts \\ []) do
	type = Keyword.get(opts, :type, type_from_activity(activity))

	unless skip?(activity, user, opts) do
	{:ok, %{notification: notification}} =
	Multi.new()
	\|> Multi.insert(:notification, %Notification{
	user_id: user.id,
	activity: activity,
	seen: mark_as_read?(activity, user),
	type: type
	})
	\|> Marker.multi_set_last_read_id(user, "notifications")
	\|> Repo.transaction()

	notification
	end
	end

	def create_poll_notifications(%Activity{} = activity) do
	with %Object{data: %{"type" => "Question", "actor" => actor} = data} <-
	Object.normalize(activity) do
	voters =
	case data do
	%{"voters" => voters} when is_list(voters) -> voters
	_ -> []
	end

	notifications =
	Enum.reduce([actor \| voters], [], fn ap_id, acc ->
	with %User{local: true} = user <- User.get_by_ap_id(ap_id) do
	[create_notification(activity, user, type: "poll") \| acc]
	else
	_ -> acc
	end
	end)

	{:ok, notifications}
	end
	end

	@doc """
	Returns a tuple with 2 elements:
	{notification-enabled receivers, currently disabled receivers (blocking / [thread] muting)}

	NOTE: might be called for FAKE Activities, see ActivityPub.Utils.get_notified_from_object/1
	"""
	@spec get_notified_from_activity(Activity.t(), boolean()) :: list(User.t())
	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",
	"EmojiReact",
	"Flag",
	"Update"
	] do
	potential_receiver_ap_ids = get_potential_receiver_ap_ids(activity)

	potential_receivers =
	User.get_users_from_set(potential_receiver_ap_ids, local_only: local_only)

	notification_enabled_ap_ids =
	potential_receiver_ap_ids
	\|> exclude_domain_blocker_ap_ids(activity, potential_receivers)
	\|> exclude_relationship_restricted_ap_ids(activity)
	\|> exclude_thread_muter_ap_ids(activity)

	Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
	end

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

	def get_notified_subscribers_from_activity(activity, local_only \\ true)

	def get_notified_subscribers_from_activity(
	%Activity{data: %{"type" => "Create"}} = activity,
	local_only
	) do
	notification_enabled_ap_ids =
	[]
	\|> Utils.maybe_notify_subscribers(activity)

	potential_receivers =
	User.get_users_from_set(notification_enabled_ap_ids, local_only: local_only)

	Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
	end

	def get_notified_subscribers_from_activity(_, _), do: []

	# For some activities, only notify the author of the object
	def get_potential_receiver_ap_ids(%{data: %{"type" => type, "object" => object_id}})
	when type in ~w{Like Announce EmojiReact} do
	case Object.get_cached_by_ap_id(object_id) do
	%Object{data: %{"actor" => actor}} ->
	[actor]

	_ ->
	[]
	end
	end

	def get_potential_receiver_ap_ids(%{data: %{"type" => "Follow", "object" => object_id}}) do
	[object_id]
	end

	def get_potential_receiver_ap_ids(%{data: %{"type" => "Flag", "actor" => actor}}) do
	(User.all_users_with_privilege(:reports_manage_reports)
	\|> Enum.map(fn user -> user.ap_id end)) --
	[actor]
	end

	# Update activity: notify all who repeated this
	def get_potential_receiver_ap_ids(%{data: %{"type" => "Update", "actor" => actor}} = activity) do
	with %Object{data: %{"id" => object_id}} <- Object.normalize(activity, fetch: false) do
	repeaters =
	Activity.Queries.by_type("Announce")
	\|> Activity.Queries.by_object_id(object_id)
	\|> Activity.with_joined_user_actor()
	\|> where([a, u], u.local)
	\|> select([a, u], u.ap_id)
	\|> Repo.all()

	repeaters -- [actor]
	end
	end

	def get_potential_receiver_ap_ids(activity) do
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	\|> Utils.maybe_notify_followers(activity)
	\|> Enum.uniq()
	end

	@doc "Filters out AP IDs domain-blocking and not following the activity's actor"
	def exclude_domain_blocker_ap_ids(ap_ids, activity, preloaded_users \\ [])

	def exclude_domain_blocker_ap_ids([], _activity, _preloaded_users), do: []

	def exclude_domain_blocker_ap_ids(ap_ids, %Activity{} = activity, preloaded_users) do
	activity_actor_domain = activity.actor && URI.parse(activity.actor).host

	users =
	ap_ids
	\|> Enum.map(fn ap_id ->
	Enum.find(preloaded_users, &(&1.ap_id == ap_id)) \|\|
	User.get_cached_by_ap_id(ap_id)
	end)
	\|> Enum.filter(& &1)

	domain_blocker_ap_ids = for u <- users, activity_actor_domain in u.domain_blocks, do: u.ap_id

	domain_blocker_follower_ap_ids =
	if Enum.any?(domain_blocker_ap_ids) do
	activity
	\|> Activity.user_actor()
	\|> FollowingRelationship.followers_ap_ids(domain_blocker_ap_ids)
	else
	[]
	end

	ap_ids
	\|> Kernel.--(domain_blocker_ap_ids)
	\|> Kernel.++(domain_blocker_follower_ap_ids)
	end

	@doc "Filters out AP IDs of users basing on their relationships with activity actor user"
	def exclude_relationship_restricted_ap_ids([], _activity), do: []

	def exclude_relationship_restricted_ap_ids(ap_ids, %Activity{} = activity) do
	relationship_restricted_ap_ids =
	activity
	\|> Activity.user_actor()
	\|> User.incoming_relationships_ungrouped_ap_ids([
	:block,
	:notification_mute
	])

	Enum.uniq(ap_ids) -- relationship_restricted_ap_ids
	end

	@doc "Filters out AP IDs of users who mute activity thread"
	def exclude_thread_muter_ap_ids([], _activity), do: []

	def exclude_thread_muter_ap_ids(ap_ids, %Activity{} = activity) do
	thread_muter_ap_ids = ThreadMute.muter_ap_ids(activity.data["context"])

	Enum.uniq(ap_ids) -- thread_muter_ap_ids
	end

	def skip?(activity, user, opts \\ [])

	@spec skip?(Activity.t(), User.t(), Keyword.t()) :: boolean()
	def skip?(%Activity{} = activity, %User{} = user, opts) do
	[
	:self,
	:internal,
	:invisible,
	:block_from_strangers,
	:recently_followed,
	:filtered
	]
	\|> Enum.find(&skip?(&1, activity, user, opts))
	end

	def skip?(_activity, _user, _opts), do: false

	@spec skip?(atom(), Activity.t(), User.t(), Keyword.t()) :: boolean()
	def skip?(:self, %Activity{} = activity, %User{} = user, opts) do
	cond do
	opts[:type] == "poll" -> false
	activity.data["actor"] == user.ap_id -> true
	true -> false
	end
	end

	def skip?(:internal, %Activity{} = activity, _user, _opts) do
	actor = activity.data["actor"]
	user = User.get_cached_by_ap_id(actor)
	User.internal?(user)
	end

	def skip?(:invisible, %Activity{} = activity, _user, _opts) do
	actor = activity.data["actor"]
	user = User.get_cached_by_ap_id(actor)
	User.invisible?(user)
	end

	def skip?(
	:block_from_strangers,
	%Activity{} = activity,
	%User{notification_settings: %{block_from_strangers: true}} = user,
	opts
	) do
	actor = activity.data["actor"]
	follower = User.get_cached_by_ap_id(actor)

	cond do
	opts[:type] == "poll" -> false
	user.ap_id == actor -> false
	!User.following?(user, follower) -> true
	true -> false
	end
	end

	# To do: consider defining recency in hours and checking FollowingRelationship with a single SQL
	def skip?(
	:recently_followed,
	%Activity{data: %{"type" => "Follow"}} = activity,
	%User{} = user,
	_opts
	) do
	actor = activity.data["actor"]

	Notification.for_user(user)
	\|> Enum.any?(fn
	%{activity: %{data: %{"type" => "Follow", "actor" => ^actor}}} -> true
	_ -> false
	end)
	end

	def skip?(:filtered, %{data: %{"type" => type}}, _user, _opts) when type in ["Follow", "Move"],
	do: false

	def skip?(:filtered, activity, user, _opts) do
	object = Object.normalize(activity, fetch: false)

	cond do
	is_nil(object) ->
	false

	object.data["actor"] == user.ap_id ->
	false

	not is_nil(regex = Pleroma.Filter.compose_regex(user, :re)) ->
	Regex.match?(regex, object.data["content"])

	true ->
	false
	end
	end

	def skip?(_type, _activity, _user, _opts), do: false

	def mark_as_read?(activity, target_user) do
	user = Activity.user_actor(activity)
	User.mutes_user?(target_user, user) \|\| CommonAPI.thread_muted?(activity, target_user)
	end

	def for_user_and_activity(user, activity) do
	from(n in __MODULE__,
	where: n.user_id == ^user.id,
	where: n.activity_id == ^activity.id
	)
	\|> Repo.one()
	end

	@spec mark_context_as_read(User.t(), String.t()) :: {integer(), nil \| [term()]}
	def mark_context_as_read(%User{id: id}, context) do
	from(
	n in Notification,
	join: a in assoc(n, :activity),
	where: n.user_id == ^id,
	where: n.seen == false,
	where: fragment("?->>'context'", a.data) == ^context
	)
	\|> Repo.update_all(set: [seen: true])
	end

	@doc "Streams a list of notifications over websockets and web push"
	@spec stream(list(Notification.t())) :: :ok
	def stream(notifications) do
	Enum.each(notifications, fn notification ->
	Streamer.stream(["user", "user:notification"], notification)
	Push.send(notification)
	end)
	end
	end
	diff --git a/lib/pleroma/web/api_spec/operations/notification_operation.ex b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	index 94d1f6b82..585718fc0 100644
	--- a/lib/pleroma/web/api_spec/operations/notification_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	@@ -1,242 +1,241 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ApiSpec.NotificationOperation do
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Operation
	alias OpenApiSpex.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	alias Pleroma.Web.ApiSpec.Schemas.Status
	alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope

	import Pleroma.Web.ApiSpec.Helpers

	def open_api_operation(action) do
	operation = String.to_existing_atom("#{action}_operation")
	apply(__MODULE__, operation, [])
	end

	def index_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Retrieve a list of notifications",
	description:
	"Notifications concerning the user. This API returns Link headers containing links to the next/previous page. However, the links can also be constructed dynamically using query params and `id` values.",
	operationId: "NotificationController.index",
	security: [%{"oAuth" => ["read:notifications"]}],
	parameters:
	[
	Operation.parameter(
	:exclude_types,
	:query,
	%Schema{type: :array, items: notification_type()},
	"Array of types to exclude"
	),
	Operation.parameter(
	:account_id,
	:query,
	%Schema{type: :string},
	"Return only notifications received from this account"
	),
	Operation.parameter(
	:exclude_visibilities,
	:query,
	%Schema{type: :array, items: VisibilityScope},
	"Exclude the notifications for activities with the given visibilities"
	),
	Operation.parameter(
	:include_types,
	:query,
	%Schema{type: :array, items: notification_type()},
	"Deprecated, use `types` instead"
	),
	Operation.parameter(
	:types,
	:query,
	%Schema{type: :array, items: notification_type()},
	"Include the notifications for activities with the given types"
	),
	Operation.parameter(
	:with_muted,
	:query,
	BooleanLike.schema(),
	"Include the notifications from muted users"
	)
	] ++ pagination_params(),
	responses: %{
	200 =>
	Operation.response("Array of notifications", "application/json", %Schema{
	type: :array,
	items: notification()
	}),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def show_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Retrieve a notification",
	description: "View information about a notification with a given ID.",
	operationId: "NotificationController.show",
	security: [%{"oAuth" => ["read:notifications"]}],
	parameters: [id_param()],
	responses: %{
	200 => Operation.response("Notification", "application/json", notification())
	}
	}
	end

	def clear_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss all notifications",
	description: "Clear all notifications from the server.",
	operationId: "NotificationController.clear",
	security: [%{"oAuth" => ["write:notifications"]}],
	responses: %{200 => empty_object_response()}
	}
	end

	def dismiss_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss a notification",
	description: "Clear a single notification from the server.",
	operationId: "NotificationController.dismiss",
	parameters: [id_param()],
	security: [%{"oAuth" => ["write:notifications"]}],
	responses: %{200 => empty_object_response()}
	}
	end

	def dismiss_via_body_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss a single notification",
	deprecated: true,
	description: "Clear a single notification from the server.",
	operationId: "NotificationController.dismiss_via_body",
	requestBody:
	request_body(
	"Parameters",
	%Schema{type: :object, properties: %{id: %Schema{type: :string}}},
	required: true
	),
	security: [%{"oAuth" => ["write:notifications"]}],
	responses: %{200 => empty_object_response()}
	}
	end

	def destroy_multiple_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss multiple notifications",
	operationId: "NotificationController.destroy_multiple",
	security: [%{"oAuth" => ["write:notifications"]}],
	parameters: [
	Operation.parameter(
	:ids,
	:query,
	%Schema{type: :array, items: %Schema{type: :string}},
	"Array of notification IDs to dismiss",
	required: true
	)
	],
	responses: %{200 => empty_object_response()}
	}
	end

	def notification do
	%Schema{
	title: "Notification",
	description: "Response schema for a notification",
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	group_key: %Schema{
	type: :string,
	description: "Group key shared by similar notifications"
	},
	type: notification_type(),
	created_at: %Schema{type: :string, format: :"date-time"},
	account: %Schema{
	allOf: [Account],
	description: "The account that performed the action that generated the notification."
	},
	status: %Schema{
	allOf: [Status],
	description:
	"Status that was the object of the notification, e.g. in mentions, reblogs, favourites, or polls.",
	nullable: true
	},
	pleroma: %Schema{
	type: :object,
	properties: %{
	is_seen: %Schema{type: :boolean},
	is_muted: %Schema{type: :boolean}
	}
	}
	},
	example: %{
	"id" => "34975861",
	"group-key" => "ungrouped-34975861",
	"type" => "mention",
	"created_at" => "2019-11-23T07:49:02.064Z",
	"account" => Account.schema().example,
	"status" => Status.schema().example,
	"pleroma" => %{"is_seen" => false, "is_muted" => false}
	}
	}
	end

	defp notification_type do
	%Schema{
	type: :string,
	enum: [
	"follow",
	"favourite",
	"reblog",
	"mention",
	"pleroma:emoji_reaction",
	"pleroma:chat_mention",
	"pleroma:report",
	"move",
	"follow_request",
	"poll",
	"status",
	"update",
	"admin.sign_up",
	"admin.report"
	],
	description: """
	The type of event that resulted in the notification.

	- `follow` - Someone followed you
	- `mention` - Someone mentioned you in their status
	- `reblog` - Someone boosted one of your statuses
	- `favourite` - Someone favourited one of your statuses
	- `poll` - A poll you have voted in or created has ended
	- `move` - Someone moved their account
	- `pleroma:emoji_reaction` - Someone reacted with emoji to your status
	- `pleroma:chat_mention` - Someone mentioned you in a chat message
	- - `pleroma:report` - Someone was reported
	- `status` - Someone you are subscribed to created a status
	- `update` - A status you boosted has been edited
	- `admin.sign_up` - Someone signed up (optionally sent to admins)
	- `admin.report` - A new report has been filed
	"""
	}
	end

	defp id_param do
	Operation.parameter(:id, :path, :string, "Notification ID",
	example: "123",
	required: true
	)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api.ex b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	index c9e045d23..a3f1c9db3 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	@@ -1,121 +1,127 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.MastodonAPI do
	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Notification
	alias Pleroma.Pagination
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	@spec follow(User.t(), User.t(), map) :: {:ok, User.t()} \| {:error, String.t()}
	def follow(follower, followed, params \\ %{}) do
	result =
	if not User.following?(follower, followed) do
	CommonAPI.follow(followed, follower)
	else
	{:ok, followed, follower, nil}
	end

	with {:ok, _followed, follower, _} <- result do
	options = cast_params(params)
	set_reblogs_visibility(options[:reblogs], result)
	set_subscription(options[:notify], result)
	{:ok, follower}
	end
	end

	defp set_reblogs_visibility(false, {:ok, followed, follower, _}) do
	CommonAPI.hide_reblogs(followed, follower)
	end

	defp set_reblogs_visibility(_, {:ok, followed, follower, _}) do
	CommonAPI.show_reblogs(followed, follower)
	end

	defp set_subscription(true, {:ok, followed, follower, _}) do
	User.subscribe(follower, followed)
	end

	defp set_subscription(false, {:ok, followed, follower, _}) do
	User.unsubscribe(follower, followed)
	end

	defp set_subscription(_, _), do: {:ok, nil}

	@spec get_followers(User.t(), map()) :: list(User.t())
	def get_followers(user, params \\ %{}) do
	user
	\|> User.get_followers_query()
	\|> Pagination.fetch_paginated(params)
	end

	def get_friends(user, params \\ %{}) do
	user
	\|> User.get_friends_query()
	\|> Pagination.fetch_paginated(params)
	end

	def get_notifications(user, params \\ %{}) do
	options =
	- cast_params(params) \|> Map.update(:include_types, [], fn include_types -> include_types end)
	+ cast_params(params)
	+ \|> Map.update(:types, [], fn types ->
	+ if "admin.report" in types do
	+ (types -- ["admin.report"]) ++ ["pleroma:report"]
	+ else
	+ types
	+ end
	+ end)

	options =
	- if ("pleroma:report" not in options.include_types and
	- User.privileged?(user, :reports_manage_reports)) or
	+ if "pleroma:report" not in options.types or
	User.privileged?(user, :reports_manage_reports) do
	options
	else
	options
	\|> Map.update(:exclude_types, ["pleroma:report"], fn current_exclude_types ->
	current_exclude_types ++ ["pleroma:report"]
	end)
	end

	user
	\|> Notification.for_user_query(options)
	\|> restrict(:types, options)
	\|> restrict(:exclude_types, options)
	\|> restrict(:account_ap_id, options)
	\|> Pagination.fetch_paginated(params)
	end

	def get_scheduled_activities(user, params \\ %{}) do
	user
	\|> ScheduledActivity.for_user_query()
	\|> Pagination.fetch_paginated(params)
	end

	defp cast_params(params) do
	param_types = %{
	exclude_types: {:array, :string},
	types: {:array, :string},
	exclude_visibilities: {:array, :string},
	reblogs: :boolean,
	with_muted: :boolean,
	account_ap_id: :string,
	notify: :boolean
	}

	changeset = cast({%{}, param_types}, params, Map.keys(param_types))
	changeset.changes
	end

	defp restrict(query, :types, %{types: mastodon_types = [_ \| _]}) do
	where(query, [n], n.type in ^mastodon_types)
	end

	defp restrict(query, :exclude_types, %{exclude_types: mastodon_types = [_ \| _]}) do
	where(query, [n], n.type not in ^mastodon_types)
	end

	defp restrict(query, :account_ap_id, %{account_ap_id: account_ap_id}) do
	where(query, [n, a], a.actor == ^account_ap_id)
	end

	defp restrict(query, _, _), do: query
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/notification_view.ex b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	index c277af98b..3ab2096a9 100644
	--- a/lib/pleroma/web/mastodon_api/views/notification_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	@@ -1,183 +1,187 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	alias Pleroma.Activity
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.AdminAPI.Report
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView

	defp object_id_for(%{data: %{"object" => %{"id" => id}}}) when is_binary(id), do: id

	defp object_id_for(%{data: %{"object" => id}}) when is_binary(id), do: id

	@parent_types ~w{Like Announce EmojiReact Update}

	def render("index.json", %{notifications: notifications, for: reading_user} = opts) do
	activities = Enum.map(notifications, & &1.activity)

	parent_activities =
	activities
	\|> Enum.filter(fn
	%{data: %{"type" => type}} ->
	type in @parent_types
	end)
	\|> Enum.map(&object_id_for/1)
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Pleroma.Repo.all()

	relationships_opt =
	cond do
	Map.has_key?(opts, :relationships) ->
	opts[:relationships]

	is_nil(reading_user) ->
	UserRelationship.view_relationships_option(nil, [])

	true ->
	move_activities_targets =
	activities
	\|> Enum.filter(&(&1.data["type"] == "Move"))
	\|> Enum.map(&User.get_cached_by_ap_id(&1.data["target"]))
	\|> Enum.filter(& &1)

	actors =
	activities
	\|> Enum.map(fn a -> User.get_cached_by_ap_id(a.data["actor"]) end)
	\|> Enum.filter(& &1)
	\|> Kernel.++(move_activities_targets)

	UserRelationship.view_relationships_option(reading_user, actors, subset: :source_mutes)
	end

	opts =
	opts
	\|> Map.put(:parent_activities, parent_activities)
	\|> Map.put(:relationships, relationships_opt)

	safe_render_many(notifications, NotificationView, "show.json", opts)
	end

	def render(
	"show.json",
	%{
	notification: %Notification{activity: activity} = notification,
	for: reading_user
	} = opts
	) do
	actor = User.get_cached_by_ap_id(activity.data["actor"])

	parent_activity_fn = fn ->
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(opts[:parent_activities], object_id_for(activity))
	else
	Activity.get_create_by_object_ap_id(object_id_for(activity))
	end
	end

	# Note: :relationships contain user mutes (needed for :muted flag in :status)
	status_render_opts = %{relationships: opts[:relationships]}
	account = AccountView.render("show.json", %{user: actor, for: reading_user})

	response = %{
	id: to_string(notification.id),
	group_key: "ungrouped-" <> to_string(notification.id),
	- type: notification.type,
	+ type: get_notification_type(notification),
	created_at: CommonAPI.Utils.to_masto_date(notification.inserted_at),
	account: account,
	pleroma: %{
	is_muted: User.mutes?(reading_user, actor),
	is_seen: notification.seen
	}
	}

	case notification.type do
	"mention" ->
	put_status(response, activity, reading_user, status_render_opts)

	"status" ->
	put_status(response, activity, reading_user, status_render_opts)

	"favourite" ->
	put_status(response, parent_activity_fn.(), reading_user, status_render_opts)

	"reblog" ->
	put_status(response, parent_activity_fn.(), reading_user, status_render_opts)

	"update" ->
	put_status(response, parent_activity_fn.(), reading_user, status_render_opts)

	"move" ->
	put_target(response, activity, reading_user, %{})

	"poll" ->
	put_status(response, activity, reading_user, status_render_opts)

	"pleroma:emoji_reaction" ->
	response
	\|> put_status(parent_activity_fn.(), reading_user, status_render_opts)
	\|> put_emoji(activity)

	"pleroma:chat_mention" ->
	put_chat_message(response, activity, reading_user, status_render_opts)

	"pleroma:report" ->
	put_report(response, activity)

	type when type in ["follow", "follow_request"] ->
	response
	end
	end

	+ defp get_notification_type(%Notification{type: "pleroma:report"}), do: "admin.report"
	+
	+ defp get_notification_type(%Notification{type: type}), do: type
	+
	defp put_report(response, activity) do
	report_render = ReportView.render("show.json", Report.extract_report_info(activity))

	Map.put(response, :report, report_render)
	end

	defp put_emoji(response, activity) do
	response
	\|> Map.put(:emoji, activity.data["content"])
	\|> Map.put(:emoji_url, MediaProxy.url(Pleroma.Emoji.emoji_url(activity.data)))
	end

	defp put_chat_message(response, activity, reading_user, opts) do
	object = Object.normalize(activity, fetch: false)
	author = User.get_cached_by_ap_id(object.data["actor"])
	chat = Pleroma.Chat.get(reading_user.id, author.ap_id)
	cm_ref = MessageReference.for_chat_and_object(chat, object)
	render_opts = Map.merge(opts, %{for: reading_user, chat_message_reference: cm_ref})
	chat_message_render = MessageReferenceView.render("show.json", render_opts)

	Map.put(response, :chat_message, chat_message_render)
	end

	defp put_status(response, activity, reading_user, opts) do
	status_render_opts = Map.merge(opts, %{activity: activity, for: reading_user})
	status_render = StatusView.render("show.json", status_render_opts)

	Map.put(response, :status, status_render)
	end

	defp put_target(response, activity, reading_user, opts) do
	target_user = User.get_cached_by_ap_id(activity.data["target"])
	target_render_opts = Map.merge(opts, %{user: target_user, for: reading_user})
	target_render = AccountView.render("show.json", target_render_opts)

	Map.put(response, :target, target_render)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs b/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs
	index 88f2fb7af..d7acde46d 100644
	--- a/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs
	@@ -1,714 +1,740 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationControllerTest do
	use Pleroma.Web.ConnCase, async: false

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

	import Pleroma.Factory

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	test "does NOT render account/pleroma/relationship by default" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hi @#{user.nickname}"})
	{:ok, [_notification]} = Notification.create_notifications(activity)

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

	assert Enum.all?(response, fn n ->
	get_in(n, ["account", "pleroma", "relationship"]) == %{}
	end)
	end

	test "list of notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	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 class=\"u-url mention\" data-user=\"#{user.id}\" href=\"#{user.ap_id}\" rel=\"ugc\">@<span>#{user.nickname}</span></a></span>"

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

	assert response == expected_response
	end

	test "by default, does not contain pleroma:chat_mention" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, _activity} = CommonAPI.post_chat_message(other_user, user, "hey")

	result =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(200)

	assert [] == result

	result =
	conn
	\|> get("/api/v1/notifications?include_types[]=pleroma:chat_mention")
	\|> json_response_and_validate_schema(200)

	assert [_] = result
	end

	- test "by default, does not contain pleroma:report" do
	+ test "by default, does not contain admin.report" do
	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])

	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, user} = user \|> User.admin_api_update(%{is_moderator: true})

	%{conn: conn} = oauth_access(["read:notifications"], user: user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})

	{:ok, _report} =
	CommonAPI.report(third_user, %{account_id: other_user.id, status_ids: [activity.id]})

	result =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(200)

	assert [] == result

	+ result =
	+ conn
	+ \|> get("/api/v1/notifications?include_types[]=admin.report")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert [_] = result
	+ end
	+
	+ test "fallback from pleroma:report works" do
	+ clear_config([:instance, :moderator_privileges], [:reports_manage_reports])
	+
	+ user = insert(:user)
	+ reporter = insert(:user)
	+ reported = insert(:user)
	+
	+ {:ok, user} = user \|> User.admin_api_update(%{is_moderator: true})
	+ %{conn: conn} = oauth_access(["read:notifications"], user: user)
	+ {:ok, _report} = CommonAPI.report(reporter, %{account_id: reported.id})
	+
	result =
	conn
	\|> get("/api/v1/notifications?include_types[]=pleroma:report")
	\|> json_response_and_validate_schema(200)

	assert [_] = result
	end

	- test "Pleroma:report is hidden for non-privileged users" do
	+ test "Admin.report is hidden for non-privileged users" do
	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])

	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

	{:ok, user} = user \|> User.admin_api_update(%{is_moderator: true})

	%{conn: conn} = oauth_access(["read:notifications"], user: user)

	{:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})

	{:ok, _report} =
	CommonAPI.report(third_user, %{account_id: other_user.id, status_ids: [activity.id]})

	result =
	conn
	\|> get("/api/v1/notifications?include_types[]=pleroma:report")
	\|> json_response_and_validate_schema(200)

	assert [_] = result

	clear_config([:instance, :moderator_privileges], [])

	result =
	conn
	\|> get("/api/v1/notifications?include_types[]=pleroma:report")
	\|> json_response_and_validate_schema(200)

	assert [] == result
	+
	+ result =
	+ conn
	+ \|> get("/api/v1/notifications?include_types[]=admin.report")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert [] == result
	end

	test "excludes mentions from blockers when blockers_visible is false" do
	clear_config([:activitypub, :blockers_visible], false)

	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	blocker = insert(:user)

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

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

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

	assert [] == json_response_and_validate_schema(conn, 200)
	end

	test "getting a single notification" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

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

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

	conn = get(conn, "/api/v1/notifications/#{notification.id}")

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

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

	test "dismissing a single notification (deprecated endpoint)" do
	%{user: user, conn: conn} = oauth_access(["write:notifications"])
	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)
	\|> put_req_header("content-type", "application/json")
	\|> post("/api/v1/notifications/dismiss", %{"id" => to_string(notification.id)})

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

	test "dismissing a single notification" do
	%{user: user, conn: conn} = oauth_access(["write:notifications"])
	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/#{notification.id}/dismiss")

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

	test "clearing all notifications" do
	%{user: user, conn: conn} = oauth_access(["write:notifications", "read:notifications"])
	other_user = insert(:user)

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

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

	ret_conn = post(conn, "/api/v1/notifications/clear")

	assert %{} = json_response_and_validate_schema(ret_conn, 200)

	ret_conn = get(conn, "/api/v1/notifications")

	assert all = json_response_and_validate_schema(ret_conn, 200)
	assert all == []
	end

	test "paginates notifications using min_id, since_id, max_id, and limit" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	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_and_validate_schema(: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_and_validate_schema(: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_and_validate_schema(:ok)

	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
	end

	describe "exclude_visibilities" do
	test "filters notifications for mentions" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	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"})

	query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "private"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
	assert id == direct_activity.id

	query = params_to_query(%{exclude_visibilities: ["public", "unlisted", "direct"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
	assert id == private_activity.id

	query = params_to_query(%{exclude_visibilities: ["public", "private", "direct"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
	assert id == unlisted_activity.id

	query = params_to_query(%{exclude_visibilities: ["unlisted", "private", "direct"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"status" => %{"id" => id}}] = json_response_and_validate_schema(conn_res, 200)
	assert id == public_activity.id
	end

	test "filters notifications for Like activities" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:notifications"])

	{: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
	\|> get("/api/v1/notifications?exclude_visibilities[]=direct")
	\|> json_response_and_validate_schema(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
	\|> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
	\|> json_response_and_validate_schema(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
	\|> get("/api/v1/notifications?exclude_visibilities[]=private")
	\|> json_response_and_validate_schema(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
	\|> get("/api/v1/notifications?exclude_visibilities[]=public")
	\|> json_response_and_validate_schema(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" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:notifications"])

	{: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
	\|> get("/api/v1/notifications?exclude_visibilities[]=unlisted")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["status"]["id"])

	assert public_activity.id in activity_ids
	refute unlisted_activity.id in activity_ids
	end

	test "doesn't return less than the requested amount of records when the user's reply is liked" do
	user = insert(:user)
	%{user: other_user, conn: conn} = oauth_access(["read:notifications"])

	{:ok, mention} =
	CommonAPI.post(user, %{status: "@#{other_user.nickname}", visibility: "public"})

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

	{:ok, reply} =
	CommonAPI.post(other_user, %{
	status: ".",
	visibility: "public",
	in_reply_to_status_id: activity.id
	})

	{:ok, _favorite} = CommonAPI.favorite(reply.id, user)

	activity_ids =
	conn
	\|> get("/api/v1/notifications?exclude_visibilities[]=direct&limit=2")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["status"]["id"])

	assert [reply.id, mention.id] == activity_ids
	end
	end

	test "filters notifications using exclude_types" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	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(user, other_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)

	query = params_to_query(%{exclude_types: ["mention", "favourite", "reblog"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)

	query = params_to_query(%{exclude_types: ["favourite", "reblog", "follow"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"id" => ^mention_notification_id}] =
	json_response_and_validate_schema(conn_res, 200)

	query = params_to_query(%{exclude_types: ["reblog", "follow", "mention"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"id" => ^favorite_notification_id}] =
	json_response_and_validate_schema(conn_res, 200)

	query = params_to_query(%{exclude_types: ["follow", "mention", "favourite"]})
	conn_res = get(conn, "/api/v1/notifications?" <> query)

	assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)
	end

	test "filters notifications using types" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	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(user, other_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_res = get(conn, "/api/v1/notifications?types[]=follow")

	assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications?types[]=mention")

	assert [%{"id" => ^mention_notification_id}] =
	json_response_and_validate_schema(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications?types[]=favourite")

	assert [%{"id" => ^favorite_notification_id}] =
	json_response_and_validate_schema(conn_res, 200)

	conn_res = get(conn, "/api/v1/notifications?types[]=reblog")

	assert [%{"id" => ^reblog_notification_id}] = json_response_and_validate_schema(conn_res, 200)

	result = conn \|> get("/api/v1/notifications") \|> json_response_and_validate_schema(200)

	assert length(result) == 4

	query = params_to_query(%{types: ["follow", "mention", "favourite", "reblog"]})

	result =
	conn
	\|> get("/api/v1/notifications?" <> query)
	\|> json_response_and_validate_schema(200)

	assert length(result) == 4
	end

	test "filtering falls back to include_types" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(other_user, %{status: "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, _activity} = CommonAPI.favorite(create_activity.id, other_user)
	{:ok, _activity} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(user, other_user)

	follow_notification_id = get_notification_id_by_activity(follow_activity)

	conn_res = get(conn, "/api/v1/notifications?include_types[]=follow")

	assert [%{"id" => ^follow_notification_id}] = json_response_and_validate_schema(conn_res, 200)
	end

	test "destroy multiple" do
	%{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
	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)

	result =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result

	conn2 =
	conn
	\|> assign(:user, other_user)
	\|> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:notifications"]))

	result =
	conn2
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	query = params_to_query(%{ids: [notification1_id, notification2_id]})
	conn_destroy = delete(conn, "/api/v1/notifications/destroy_multiple?" <> query)

	assert json_response_and_validate_schema(conn_destroy, 200) == %{}

	result =
	conn2
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(:ok)

	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
	end

	test "doesn't see notifications after muting user with notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user2, user)
	{:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(ret_conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2)

	conn = get(conn, "/api/v1/notifications")

	assert json_response_and_validate_schema(conn, 200) == []
	end

	test "see notifications after muting user without notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user2, user)
	{:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(ret_conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2, %{notifications: false})

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(conn, 200)) == 1
	end

	test "see notifications after muting user with notifications and with_muted parameter" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	user2 = insert(:user)

	{:ok, _, _, _} = CommonAPI.follow(user2, user)
	{:ok, _} = CommonAPI.post(user2, %{status: "hey @#{user.nickname}"})

	ret_conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(ret_conn, 200)) == 1

	{:ok, _user_relationships} = User.mute(user, user2)

	conn = get(conn, "/api/v1/notifications?with_muted=true")

	assert length(json_response_and_validate_schema(conn, 200)) == 1
	end

	test "see move notifications" do
	old_user = insert(:user)
	new_user = insert(:user, also_known_as: [old_user.ap_id])
	%{user: follower, conn: conn} = oauth_access(["read:notifications"])

	User.follow(follower, old_user)
	Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
	Pleroma.Tests.ObanHelpers.perform_all()

	conn = get(conn, "/api/v1/notifications")

	assert length(json_response_and_validate_schema(conn, 200)) == 1
	end

	describe "link headers" do
	test "preserves parameters in link headers" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

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

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

	notification1 = Repo.get_by(Notification, activity_id: activity1.id)
	notification2 = Repo.get_by(Notification, activity_id: activity2.id)

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

	assert [link_header] = get_resp_header(conn, "link")
	assert link_header =~ ~r/limit=5/
	assert link_header =~ ~r/min_id=#{notification2.id}/
	assert link_header =~ ~r/max_id=#{notification1.id}/
	end
	end

	describe "from specified user" do
	test "account_id" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])

	%{id: account_id} = other_user1 = insert(:user)
	other_user2 = insert(:user)

	{:ok, _activity} = CommonAPI.post(other_user1, %{status: "hi @#{user.nickname}"})
	{:ok, _activity} = CommonAPI.post(other_user2, %{status: "bye @#{user.nickname}"})

	assert [%{"account" => %{"id" => ^account_id}}] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications?account_id=#{account_id}")
	\|> json_response_and_validate_schema(200)

	assert %{"error" => "Account is not found"} =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications?account_id=cofe")
	\|> json_response_and_validate_schema(404)
	end
	end

	defp get_notification_id_by_activity(%{id: id}) do
	Notification
	\|> Repo.get_by(activity_id: id)
	\|> Map.get(:id)
	\|> to_string()
	end

	defp params_to_query(%{} = params) do
	Enum.map_join(params, "&", fn
	{k, v} when is_list(v) -> Enum.map_join(v, "&", &"#{k}[]=#{&1}")
	{k, v} -> k <> "=" <> v
	end)
	end
	end
	diff --git a/test/pleroma/web/mastodon_api/views/notification_view_test.exs b/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	index ce5ddd0fc..7a4f5b2ea 100644
	--- a/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	@@ -1,374 +1,374 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
	use Pleroma.DataCase, async: false

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Chat.MessageReference
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.AdminAPI.Report
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView
	import Pleroma.Factory

	setup do
	Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Test.StaticConfig)
	:ok
	end

	defp test_notifications_rendering(notifications, user, expected_result) do
	result = NotificationView.render("index.json", %{notifications: notifications, for: user})

	assert expected_result == result

	result =
	NotificationView.render("index.json", %{
	notifications: notifications,
	for: user,
	relationships: nil
	})

	assert expected_result == result
	end

	test "ChatMessage notification" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, activity} = CommonAPI.post_chat_message(user, recipient, "what's up my dude")

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

	object = Object.normalize(activity, fetch: false)
	chat = Chat.get(recipient.id, user.ap_id)

	cm_ref = MessageReference.for_chat_and_object(chat, object)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:chat_mention",
	account: AccountView.render("show.json", %{user: user, for: recipient}),
	chat_message: MessageReferenceView.render("show.json", %{chat_message_reference: cm_ref}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], recipient, [expected])
	end

	test "Mention notification" do
	user = insert(:user)
	mentioned_user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{status: "hey @#{mentioned_user.nickname}"})
	{:ok, [notification]} = Notification.create_notifications(activity)
	user = User.get_cached_by_id(user.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "mention",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: mentioned_user
	}),
	status: StatusView.render("show.json", %{activity: activity, for: mentioned_user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], mentioned_user, [expected])
	end

	test "Favourite notification" do
	user = insert(:user)
	another_user = insert(:user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, favorite_activity} = CommonAPI.favorite(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(favorite_activity)
	create_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "favourite",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: create_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Reblog notification" do
	user = insert(:user)
	another_user = insert(:user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(reblog_activity)
	reblog_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "reblog",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: reblog_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Follow notification" do
	follower = insert(:user)
	followed = insert(:user)
	{:ok, followed, follower, _activity} = CommonAPI.follow(followed, follower)
	notification = Notification \|> Repo.one() \|> Repo.preload(:activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "follow",
	account: AccountView.render("show.json", %{user: follower, for: followed}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], followed, [expected])

	User.perform(:delete, follower)
	refute Repo.one(Notification)
	end

	test "Move notification" 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()

	old_user = refresh_record(old_user)
	new_user = refresh_record(new_user)

	[notification] = Notification.for_user(follower)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "move",
	account: AccountView.render("show.json", %{user: old_user, for: follower}),
	target: AccountView.render("show.json", %{user: new_user, for: follower}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], follower, [expected])
	end

	test "EmojiReact notification" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
	{:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	activity = Repo.get(Activity, activity.id)

	[notification] = Notification.for_user(user)

	assert notification

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:emoji_reaction",
	emoji: "☕",
	account: AccountView.render("show.json", %{user: other_user, for: user}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	emoji_url: nil
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "EmojiReact custom emoji notification" do
	user = insert(:user)
	other_user = insert(:user)

	note =
	insert(:note,
	user: user,
	data: %{
	"reactions" => [
	["👍", [user.ap_id], nil],
	["dinosaur", [user.ap_id], "http://localhost:4001/emoji/dino walking.gif"]
	]
	}
	)

	activity = insert(:note_activity, note: note, user: user)

	{:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "dinosaur")

	activity = Repo.get(Activity, activity.id)

	[notification] = Notification.for_user(user)

	assert notification

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "pleroma:emoji_reaction",
	emoji: ":dinosaur:",
	account: AccountView.render("show.json", %{user: other_user, for: user}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	emoji_url: "http://localhost:4001/emoji/dino walking.gif"
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Poll notification" do
	user = insert(:user)
	activity = insert(:question_activity, user: user)
	{:ok, [notification]} = Notification.create_poll_notifications(activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "poll",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: user
	}),
	status: StatusView.render("show.json", %{activity: activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Report notification" do
	clear_config([:instance, :moderator_privileges], [:reports_manage_reports])

	reporting_user = insert(:user)
	reported_user = insert(:user)
	moderator_user = insert(:user, is_moderator: true)

	{:ok, activity} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
	{:ok, [notification]} = Notification.create_notifications(activity)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	- type: "pleroma:report",
	+ type: "admin.report",
	account: AccountView.render("show.json", %{user: reporting_user, for: moderator_user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	report: ReportView.render("show.json", Report.extract_report_info(activity))
	}

	test_notifications_rendering([notification], moderator_user, [expected])
	end

	test "Edit notification" do
	user = insert(:user)
	repeat_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "mew"})
	{:ok, _} = CommonAPI.repeat(activity.id, repeat_user)
	{:ok, update} = CommonAPI.update(activity, user, %{status: "mew mew"})

	user = Pleroma.User.get_by_ap_id(user.ap_id)
	activity = Pleroma.Activity.normalize(activity)
	update = Pleroma.Activity.normalize(update)

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

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "update",
	account: AccountView.render("show.json", %{user: user, for: repeat_user}),
	created_at: Utils.to_masto_date(notification.inserted_at),
	status: StatusView.render("show.json", %{activity: activity, for: repeat_user})
	}

	test_notifications_rendering([notification], repeat_user, [expected])
	end

	test "muted notification" do
	user = insert(:user)
	another_user = insert(:user)

	{:ok, _} = Pleroma.UserRelationship.create_mute(user, another_user)
	{:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
	{:ok, favorite_activity} = CommonAPI.favorite(create_activity.id, another_user)
	{:ok, [notification]} = Notification.create_notifications(favorite_activity)
	create_activity = Activity.get_by_id(create_activity.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: true, is_muted: true},
	type: "favourite",
	account: AccountView.render("show.json", %{user: another_user, for: user}),
	status: StatusView.render("show.json", %{activity: create_activity, for: user}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], user, [expected])
	end

	test "Subscribed status notification" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

	{:ok, activity} = CommonAPI.post(user, %{status: "hi"})
	{:ok, [notification]} = Notification.create_notifications(activity)

	user = User.get_cached_by_id(user.id)

	expected = %{
	id: to_string(notification.id),
	group_key: "ungrouped-#{to_string(notification.id)}",
	pleroma: %{is_seen: false, is_muted: false},
	type: "status",
	account:
	AccountView.render("show.json", %{
	user: user,
	for: subscriber
	}),
	status: StatusView.render("show.json", %{activity: activity, for: subscriber}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

	test_notifications_rendering([notification], subscriber, [expected])
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 29, 5:37 AM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1736814
Default Alt Text: (107 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions