No OneTemporary
Actions

Size

135 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/grouped-notifications-api.add b/changelog.d/grouped-notifications-api.add
	index 82ce8b178..8c2cc5397 100644
	--- a/changelog.d/grouped-notifications-api.add
	+++ b/changelog.d/grouped-notifications-api.add
	@@ -1 +1 @@
	-Add Mastodon-compatible grouped notifications API endpoints under `/api/v2/notifications`
	+Add Mastodon-compatible grouped notifications API endpoints under `/api/v2/notifications` for newly-created notifications
	diff --git a/lib/pleroma/notification.ex b/lib/pleroma/notification.ex
	index ec10854e3..afd750823 100644
	--- a/lib/pleroma/notification.ex
	+++ b/lib/pleroma/notification.ex
	@@ -1,856 +1,867 @@
	# 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)
	+ field(:group_key, :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})
	+ \|> changeset(%{type: type, group_key: grouped_notification_key(type, activity)})
	\|> 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

	@groupable_notification_types ~w{favourite follow reblog}
	@group_bucket_seconds 12 * 60 * 60

	def groupable_notification_types, do: @groupable_notification_types

	def group_notifications(notifications, grouped_types \\ nil) do
	grouped_types = normalize_grouped_types(grouped_types)

	{group_keys, grouped_notifications} =
	Enum.reduce(notifications, {[], %{}}, fn notification,
	{group_keys, grouped_notifications} ->
	group_key = group_key(notification, grouped_types)

	if Map.has_key?(grouped_notifications, group_key) do
	{group_keys, Map.update!(grouped_notifications, group_key, &[notification \| &1])}
	else
	{[group_key \| group_keys], Map.put(grouped_notifications, group_key, [notification])}
	end
	end)

	group_keys
	\|> Enum.reverse()
	\|> Enum.map(fn group_key ->
	grouped_notifications
	\|> Map.fetch!(group_key)
	\|> Enum.reverse()
	end)
	end

	def group_key(notification, grouped_types \\ nil)

	def group_key(%Notification{} = notification, nil) do
	group_key(notification, @groupable_notification_types)
	end

	- def group_key(%Notification{type: type} = notification, grouped_types) do
	+ def group_key(%Notification{type: type, group_key: group_key} = notification, grouped_types) do
	grouped_types = normalize_grouped_types(grouped_types)

	- if type in @groupable_notification_types and type in grouped_types do
	- case group_target_id(notification) do
	- nil -> ungrouped_group_key(notification)
	- target_id -> "#{type}-#{target_id}-#{group_time_bucket(notification)}"
	- end
	+ if type in @groupable_notification_types and type in grouped_types and is_binary(group_key) do
	+ group_key
	else
	ungrouped_group_key(notification)
	end
	end

	def normalize_grouped_types(nil), do: @groupable_notification_types
	def normalize_grouped_types(types) when is_list(types), do: types
	def normalize_grouped_types(type), do: [type]

	defp ungrouped_group_key(%Notification{id: id}), do: "ungrouped-#{id}"

	- defp group_time_bucket(%Notification{inserted_at: inserted_at}) do
	+ defp grouped_notification_key(type, activity) when type in @groupable_notification_types do
	+ with target_id when is_binary(target_id) <- group_target_id(type, activity) do
	+ # Mastodon uses Redis to reuse a recent bucket for rolling 12h windows. Pleroma keeps keys
	+ # deterministic and self-contained; clients must treat group_key as opaque either way.
	+ "#{type}-#{target_id}-#{group_time_bucket(activity)}"
	+ end
	+ end
	+
	+ defp grouped_notification_key(_type, _activity), do: nil
	+
	+ defp group_time_bucket(%Activity{inserted_at: inserted_at}) when not is_nil(inserted_at) do
	inserted_at
	\|> NaiveDateTime.to_erl()
	\|> :calendar.datetime_to_gregorian_seconds()
	\|> div(@group_bucket_seconds)
	end

	- defp group_target_id(%Notification{type: type, activity: activity})
	- when type in ["favourite", "reblog"] do
	+ defp group_time_bucket(_),
	+ do: group_time_bucket(%Activity{inserted_at: NaiveDateTime.utc_now()})
	+
	+ defp group_target_id(type, activity) when type in ["favourite", "reblog"] do
	with object_id when is_binary(object_id) <- object_id_for(activity),
	%Activity{id: id} <- Activity.get_create_by_object_ap_id(object_id) do
	to_string(id)
	else
	_ -> nil
	end
	end

	- defp group_target_id(%Notification{type: "follow", activity: %{data: %{"object" => ap_id}}}) do
	+ defp group_target_id("follow", %{data: %{"object" => ap_id}}) do
	case User.get_cached_by_ap_id(ap_id) do
	%User{id: id} -> to_string(id)
	_ -> nil
	end
	end

	- defp group_target_id(_), do: nil
	+ defp group_target_id(_, _), do: nil

	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
	defp object_id_for(_), do: nil

	@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])
	+ \|> cast(attrs, [:seen, :type, :group_key])
	\|> 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
	)

	{:ok, %{marker: marker}} =
	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()

	Streamer.stream(["user", "user:notification"], marker)

	{:ok, %{marker: marker}}
	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
	+ type: type,
	+ group_key: grouped_notification_key(type, activity)
	})
	\|> 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.get_notified_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 ba996c13b..6c8f7d5e9 100644
	--- a/lib/pleroma/web/api_spec/operations/notification_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	@@ -1,401 +1,400 @@
	# 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 grouped_index_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Retrieve grouped notifications",
	description: "Notifications concerning the user, grouped by supported notification types.",
	operationId: "NotificationController.grouped_index",
	security: [%{"oAuth" => ["read:notifications"]}],
	parameters: grouped_notification_params() ++ pagination_params(),
	responses: %{
	200 => Operation.response("Grouped notifications", "application/json", grouped_result()),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def show_group_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Retrieve a notification group",
	operationId: "NotificationController.show_group",
	security: [%{"oAuth" => ["read:notifications"]}],
	parameters: [group_key_param()],
	responses: %{
	200 => Operation.response("Grouped notifications", "application/json", grouped_result()),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

	def group_accounts_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Retrieve notification group accounts",
	operationId: "NotificationController.group_accounts",
	- security: [%{"oAuth" => ["write:notifications"]}],
	+ security: [%{"oAuth" => ["read:notifications"]}],
	parameters: [group_key_param()],
	responses: %{
	200 =>
	Operation.response("Accounts", "application/json", %Schema{
	type: :array,
	items: Account
	})
	}
	}
	end

	def unread_count_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Retrieve unread grouped notification count",
	operationId: "NotificationController.unread_count",
	security: [%{"oAuth" => ["read:notifications"]}],
	parameters:
	grouped_notification_params() ++
	[
	Operation.parameter(
	:limit,
	:query,
	%Schema{type: :integer},
	"Maximum number of notifications to count"
	)
	],
	responses: %{
	200 =>
	Operation.response("Unread notification group count", "application/json", %Schema{
	type: :object,
	properties: %{count: %Schema{type: :integer}}
	}),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	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_group_operation do
	%Operation{
	tags: ["Notifications"],
	summary: "Dismiss a notification group",
	description: "Clear all notifications in a notification group from the server.",
	operationId: "NotificationController.dismiss_group",
	parameters: [group_key_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",
	+ "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 grouped_result do
	%Schema{
	title: "GroupedNotificationsResults",
	type: :object,
	properties: %{
	accounts: %Schema{type: :array, items: Account},
	statuses: %Schema{type: :array, items: Status},
	notification_groups: %Schema{type: :array, items: notification_group()}
	},
	required: [:accounts, :statuses, :notification_groups]
	}
	end

	defp notification_group do
	%Schema{
	title: "NotificationGroup",
	type: :object,
	properties: %{
	group_key: %Schema{type: :string},
	notifications_count: %Schema{type: :integer},
	type: notification_type(),
	most_recent_notification_id: %Schema{type: :string},
	page_min_id: %Schema{type: :string, nullable: true},
	page_max_id: %Schema{type: :string, nullable: true},
	latest_page_notification_at: %Schema{type: :string, format: :"date-time", nullable: true},
	sample_account_ids: %Schema{type: :array, items: %Schema{type: :string}},
	status_id: %Schema{type: :string, nullable: true}
	},
	required: [
	:group_key,
	:notifications_count,
	:type,
	:most_recent_notification_id,
	:sample_account_ids
	]
	}
	end

	defp grouped_notification_params do
	[
	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(
	:types,
	:query,
	%Schema{type: :array, items: notification_type()},
	"Include the notifications for activities with the given types"
	),
	Operation.parameter(
	:grouped_types,
	:query,
	%Schema{type: :array, items: notification_type()},
	"Notification types that may be grouped"
	)
	]
	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

	defp group_key_param do
	Operation.parameter(:group_key, :path, :string, "Notification group key",
	example: "favourite-123",
	required: true
	)
	end
	end
	diff --git a/lib/pleroma/web/controller_helper.ex b/lib/pleroma/web/controller_helper.ex
	index b15b0ea81..eecd1774f 100644
	--- a/lib/pleroma/web/controller_helper.ex
	+++ b/lib/pleroma/web/controller_helper.ex
	@@ -1,143 +1,151 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ControllerHelper do
	use Pleroma.Web, :controller

	alias Pleroma.Pagination
	alias Pleroma.Web.Utils.Params

	def json_response(conn, status, _) when status in [204, :no_content] do
	conn
	\|> put_resp_header("content-type", "application/json")
	\|> send_resp(status, "")
	end

	def json_response(conn, status, json) do
	conn
	\|> put_status(status)
	\|> json(json)
	end

	@spec fetch_integer_param(map(), String.t() \| atom(), integer() \| nil) :: integer() \| nil
	def fetch_integer_param(params, name, default \\ nil) do
	params
	\|> Map.get(name, default)
	\|> param_to_integer(default)
	end

	defp param_to_integer(val, _) when is_integer(val), do: val

	defp param_to_integer(val, default) when is_binary(val) do
	case Integer.parse(val) do
	{res, _} -> res
	_ -> default
	end
	end

	defp param_to_integer(_, default), do: default

	def add_link_headers(conn, entries, extra_params \\ %{})

	def add_link_headers(%{assigns: %{skip_link_headers: true}} = conn, _entries, _extra_params),
	do: conn

	def add_link_headers(conn, entries, extra_params) do
	case get_pagination_fields(conn, entries, extra_params) do
	%{"next" => next_url, "prev" => prev_url} ->
	put_resp_header(conn, "link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")

	_ ->
	conn
	end
	end

	# TODO: Only fetch the params from open_api_spex when everything is converted
	@id_keys Pagination.page_keys() -- ["limit", "order"]
	+ @id_key_atoms Enum.map(@id_keys, &String.to_atom/1)
	defp build_pagination_fields(conn, min_id, max_id, extra_params, order) do
	+ path_param_keys =
	+ conn.path_params
	+ \|> Map.keys()
	+ \|> Enum.flat_map(&[&1, String.to_existing_atom(&1)])
	+
	params =
	if Map.has_key?(conn.private, :open_api_spex) do
	get_in(conn, [Access.key(:private), Access.key(:open_api_spex), Access.key(:params)])
	else
	conn.params
	end
	- \|> Map.drop(Map.keys(conn.path_params) \|> Enum.map(&String.to_existing_atom/1))
	+ \|> Map.drop(path_param_keys)
	\|> Map.merge(extra_params)
	- \|> Map.drop(@id_keys)
	+ # OpenApiSpex casts params to atoms while uncast conn params are string-keyed. Drop both so
	+ # generated links replace pagination cursors instead of preserving stale request cursors.
	+ \|> Map.drop(@id_keys ++ @id_key_atoms)

	{{next_id, nid}, {prev_id, pid}} =
	if order == :desc,
	do: {{:max_id, max_id}, {:min_id, min_id}},
	else: {{:min_id, min_id}, {:max_id, max_id}}

	id = Phoenix.Controller.current_url(conn)
	base_id = %{URI.parse(id) \| query: nil} \|> URI.to_string()

	%{
	"next" => current_url(conn, Map.put(params, next_id, nid)),
	"prev" => current_url(conn, Map.put(params, prev_id, pid)),
	"id" => id,
	"partOf" => base_id
	}
	end

	defp get_first_last_pagination_id(entries) do
	case List.last(entries) do
	%{pagination_id: last_id} when not is_nil(last_id) ->
	%{pagination_id: first_id} = List.first(entries)
	{first_id, last_id}

	%{id: last_id} ->
	%{id: first_id} = List.first(entries)
	{first_id, last_id}

	_ ->
	nil
	end
	end

	def get_pagination_fields(conn, entries, extra_params \\ %{}, order \\ :desc)

	def get_pagination_fields(conn, entries, extra_params, :desc) do
	case get_first_last_pagination_id(entries) do
	nil -> %{}
	{min_id, max_id} -> build_pagination_fields(conn, min_id, max_id, extra_params, :desc)
	end
	end

	def get_pagination_fields(conn, entries, extra_params, :asc) do
	case get_first_last_pagination_id(entries) do
	nil -> %{}
	{max_id, min_id} -> build_pagination_fields(conn, min_id, max_id, extra_params, :asc)
	end
	end

	def assign_account_by_id(%{private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	case Pleroma.User.get_cached_by_id(id) do
	%Pleroma.User{} = account -> assign(conn, :account, account)
	nil -> Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found}) \|> halt()
	end
	end

	def try_render(conn, target, params) when is_binary(target) do
	render(conn, target, params)
	end

	def try_render(conn, _, _) do
	render_error(conn, :not_implemented, "Can't display this activity")
	end

	@doc """
	Returns true if request specifies to include embedded relationships in account objects.
	May only be used in selected account-related endpoints; has no effect for status- or
	notification-related endpoints.
	"""
	# Intended for PleromaFE: https://git.pleroma.social/pleroma/pleroma-fe/-/issues/838
	def embed_relationships?(params) do
	# To do once OpenAPI transition mess is over: just `truthy_param?(params[:with_relationships])`
	params
	\|> Map.get(:with_relationships, params["with_relationships"])
	\|> Params.truthy_param?()
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex b/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	index 5cd8576c1..2cc31db0c 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	@@ -1,264 +1,259 @@
	# 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.NotificationController do
	use Pleroma.Web, :controller

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

	alias Pleroma.Notification
	alias Pleroma.User
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	- @oauth_read_actions [:show, :index, :grouped_index, :show_group, :unread_count]
	+ # Mastodon's docs currently list write:notifications for group accounts, but the endpoint is
	+ # read-only and Mastodon's implementation accepts read:notifications. Prefer least privilege.
	+ @oauth_read_actions [:show, :index, :grouped_index, :show_group, :group_accounts, :unread_count]

	plug(Pleroma.Web.ApiSpec.CastAndValidate, replace_params: false)

	plug(
	OAuthScopesPlug,
	%{scopes: ["read:notifications"]} when action in @oauth_read_actions
	)

	plug(OAuthScopesPlug, %{scopes: ["write:notifications"]} when action not in @oauth_read_actions)

	defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.NotificationOperation

	@default_notification_types ~w{
	mention
	follow
	follow_request
	reblog
	favourite
	move
	pleroma:emoji_reaction
	poll
	update
	status
	}

	# GET /api/v1/notifications
	def index(%{private: %{open_api_spex: %{params: %{account_id: account_id} = params}}} = conn, _) do
	case User.get_cached_by_id(account_id) do
	%{ap_id: account_ap_id} ->
	params =
	params
	\|> Map.delete(:account_id)
	\|> Map.put(:account_ap_id, account_ap_id)

	do_get_notifications(conn, params)

	_ ->
	conn
	\|> put_status(:not_found)
	\|> json(%{"error" => "Account is not found"})
	end
	end

	def index(%{private: %{open_api_spex: %{params: params}}} = conn, _) do
	do_get_notifications(conn, params)
	end

	# GET /api/v2/notifications
	def grouped_index(
	%{private: %{open_api_spex: %{params: %{account_id: account_id} = params}}} = conn,
	_
	) do
	case User.get_cached_by_id(account_id) do
	%{ap_id: account_ap_id} ->
	params =
	params
	\|> Map.delete(:account_id)
	\|> Map.put(:account_ap_id, account_ap_id)

	do_get_grouped_notifications(conn, params)

	_ ->
	conn
	\|> put_status(:not_found)
	\|> json(%{"error" => "Account is not found"})
	end
	end

	def grouped_index(%{private: %{open_api_spex: %{params: params}}} = conn, _) do
	do_get_grouped_notifications(conn, params)
	end

	# GET /api/v2/notifications/:group_key
	def show_group(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{group_key: group_key}}}} =
	conn,
	_
	) do
	- notifications = MastodonAPI.get_notification_group(user, group_key, %{})
	+ {notifications, notification_group_counts, notification_group_bounds} =
	+ MastodonAPI.get_notification_group_result(user, group_key, %{})

	if Enum.empty?(notifications) do
	conn
	\|> put_status(:not_found)
	\|> json(%{"error" => "Notification group is not found"})
	else
	grouped_types = if String.starts_with?(group_key, "ungrouped-"), do: [], else: nil

	render(conn, "grouped_index.json",
	notification_groups: [notifications],
	+ notification_group_counts: notification_group_counts,
	+ notification_group_bounds: notification_group_bounds,
	for: user,
	- grouped_types: grouped_types
	+ grouped_types: grouped_types,
	+ include_page_metadata: false
	)
	end
	end

	# GET /api/v2/notifications/:group_key/accounts
	def group_accounts(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{group_key: group_key}}}} =
	conn,
	_
	) do
	- users =
	- user
	- \|> MastodonAPI.get_notification_group(group_key, %{})
	- \|> notification_actors()
	+ # Mastodon paginates this endpoint in code, but the public docs say it returns accounts of all
	+ # notifications in the group and do not document cursor params here. Follow the documented API.
	+ users = MastodonAPI.get_notification_group_accounts(user, group_key)

	json(conn, AccountView.render("index.json", %{users: users, for: user}))
	end

	# GET /api/v2/notifications/unread_count
	def unread_count(
	%{private: %{open_api_spex: %{params: %{account_id: account_id} = params}}} = conn,
	_
	) do
	case User.get_cached_by_id(account_id) do
	%{ap_id: account_ap_id} ->
	params =
	params
	\|> Map.delete(:account_id)
	\|> Map.put(:account_ap_id, account_ap_id)

	do_get_unread_group_count(conn, params)

	_ ->
	conn
	\|> put_status(:not_found)
	\|> json(%{"error" => "Account is not found"})
	end
	end

	def unread_count(%{private: %{open_api_spex: %{params: params}}} = conn, _) do
	do_get_unread_group_count(conn, params)
	end

	# POST /api/v2/notifications/:group_key/dismiss
	def dismiss_group(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{group_key: group_key}}}} =
	conn,
	_
	) do
	- ids =
	- user
	- \|> MastodonAPI.get_notification_group(group_key, %{})
	- \|> Enum.map(& &1.id)
	-
	- Notification.destroy_multiple(user, ids)
	+ MastodonAPI.dismiss_notification_group(user, group_key)
	json(conn, %{})
	end

	defp do_get_notifications(%{assigns: %{user: user}} = conn, params) do
	params = normalize_notification_params(params)

	notifications = MastodonAPI.get_notifications(user, params)

	conn
	\|> add_link_headers(notifications)
	\|> render("index.json",
	notifications: notifications,
	for: user
	)
	end

	defp do_get_grouped_notifications(%{assigns: %{user: user}} = conn, params) do
	params = normalize_notification_params(params)

	- {notification_groups, page_notifications, notification_group_counts} =
	+ {notification_groups, page_notifications, notification_group_counts,
	+ notification_group_bounds} =
	MastodonAPI.get_grouped_notification_page(user, params)

	conn
	\|> add_link_headers(page_notifications)
	\|> render("grouped_index.json",
	notification_groups: notification_groups,
	notification_group_counts: notification_group_counts,
	+ notification_group_bounds: notification_group_bounds,
	for: user,
	grouped_types: params["grouped_types"]
	)
	end

	defp do_get_unread_group_count(%{assigns: %{user: user}} = conn, params) do
	params = normalize_notification_params(params)
	json(conn, %{count: MastodonAPI.unread_notification_group_count(user, params)})
	end

	defp normalize_notification_params(params) do
	params
	\|> Map.new(fn {k, v} -> {to_string(k), v} end)
	\|> Map.put_new("types", Map.get(params, :include_types, @default_notification_types))
	end

	- defp notification_actors(notifications) do
	- notifications
	- \|> Enum.map(&User.get_cached_by_ap_id(&1.activity.data["actor"]))
	- \|> Enum.filter(& &1)
	- \|> Enum.uniq_by(& &1.id)
	- end
	-
	# GET /api/v1/notifications/:id
	def show(%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	with {:ok, notification} <- Notification.get(user, id) do
	render(conn, "show.json", notification: notification, for: user)
	else
	{:error, reason} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{"error" => reason})
	end
	end

	# POST /api/v1/notifications/clear
	def clear(%{assigns: %{user: user}} = conn, _params) do
	Notification.clear(user)
	json(conn, %{})
	end

	# POST /api/v1/notifications/:id/dismiss

	def dismiss(%{private: %{open_api_spex: %{params: %{id: id}}}} = conn, _) do
	do_dismiss(conn, id)
	end

	# POST /api/v1/notifications/dismiss (deprecated)
	def dismiss_via_body(
	%{private: %{open_api_spex: %{body_params: %{id: id}}}} = conn,
	_
	) do
	do_dismiss(conn, id)
	end

	defp do_dismiss(%{assigns: %{user: user}} = conn, notification_id) do
	with {:ok, _notif} <- Notification.dismiss(user, notification_id) do
	json(conn, %{})
	else
	{:error, reason} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{"error" => reason})
	end
	end

	# DELETE /api/v1/notifications/destroy_multiple
	def destroy_multiple(
	%{assigns: %{user: user}, private: %{open_api_spex: %{params: %{ids: ids}}}} = conn,
	_
	) do
	Notification.destroy_multiple(user, ids)
	json(conn, %{})
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api.ex b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	index 57cbfd6bf..cb11a3f4a 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	@@ -1,270 +1,461 @@
	# 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.Marker
	alias Pleroma.Notification
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	+ @notification_group_sample_limit 8
	+
	@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
	user
	\|> notifications_query(params)
	\|> Pagination.fetch_paginated(params)
	end

	def get_grouped_notification_page(user, params \\ %{}) do
	- grouped_types = Map.get(params, "grouped_types", Map.get(params, :grouped_types))
	- {query, order} = group_pagination_query(notifications_query(user, params), params)
	+ grouped_types =
	+ params
	+ \|> Map.get("grouped_types", Map.get(params, :grouped_types))
	+ \|> Notification.normalize_grouped_types()
	+
	+ query = notifications_query(user, params)
	+ {order, cursor_filters} = group_pagination(params)

	- notifications =
	+ group_rows =
	query
	- \|> order_by([n], [{^order, n.id}])
	- \|> Repo.all()
	+ \|> notification_group_rows(grouped_types, grouped_limit(params), order, cursor_filters)

	- notification_group_counts =
	- Enum.frequencies_by(notifications, &Notification.group_key(&1, grouped_types))
	+ group_rows = if order == :asc, do: Enum.reverse(group_rows), else: group_rows

	- page_notifications =
	- notifications
	- \|> take_grouped_page_notifications(grouped_types, grouped_limit(params))
	+ page_notifications = representative_notifications(query, group_rows)

	- page_notifications =
	- if order == :asc, do: Enum.reverse(page_notifications), else: page_notifications
	+ notification_groups =
	+ Enum.map(group_rows, &notification_group_sample(user, params, &1.group_key))

	{
	- Notification.group_notifications(page_notifications, grouped_types),
	+ notification_groups,
	page_notifications,
	- notification_group_counts
	+ notification_group_counts(group_rows),
	+ notification_group_bounds(group_rows)
	}
	end

	def get_grouped_notification_groups(user, params \\ %{}) do
	- {groups, _notifications, _notification_group_counts} =
	+ {groups, _notifications, _notification_group_counts, _notification_group_bounds} =
	get_grouped_notification_page(user, params)

	groups
	end

	+ def get_notification_group_result(user, group_key, params \\ %{}) do
	+ notifications = notification_group_sample(user, params, group_key)
	+ metadata = notification_group_metadata(user, group_key, params)
	+
	+ if Enum.empty?(notifications) or is_nil(metadata) do
	+ {[], %{}, %{}}
	+ else
	+ {
	+ notifications,
	+ %{group_key => metadata.notifications_count},
	+ %{group_key => Map.drop(metadata, [:notifications_count])}
	+ }
	+ end
	+ end
	+
	def get_notification_group(user, group_key, params \\ %{})

	def get_notification_group(user, "ungrouped-" <> notification_id, _params) do
	case Notification.get(user, notification_id) do
	{:ok, notification} -> [notification]
	_ -> []
	end
	end

	def get_notification_group(user, group_key, params) do
	- grouped_types = Map.get(params, "grouped_types", Map.get(params, :grouped_types))
	+ notification_group_sample(user, params, group_key)
	+ end

	+ def get_notification_group_accounts(user, "ungrouped-" <> notification_id) do
	+ with {:ok, notification} <- Notification.get(user, notification_id),
	+ %User{} = actor <- User.get_cached_by_ap_id(notification.activity.data["actor"]) do
	+ [actor]
	+ else
	+ _ -> []
	+ end
	+ end
	+
	+ def get_notification_group_accounts(user, group_key) do
	user
	- \|> notifications_query(params)
	- \|> order_by([n], desc: n.id)
	+ \|> notification_group_query(group_key, %{})
	+ \|> exclude(:preload)
	+ \|> distinct(true)
	+ \|> select([user_actor: user_actor], user_actor)
	\|> Repo.all()
	- \|> Enum.filter(&(Notification.group_key(&1, grouped_types) == group_key))
	end

	- defp group_pagination_query(query, params) do
	+ def dismiss_notification_group(user, "ungrouped-" <> notification_id) do
	+ Notification.destroy_multiple(user, [notification_id])
	+ end
	+
	+ def dismiss_notification_group(%User{id: user_id}, group_key) do
	+ Notification
	+ \|> where([n], n.user_id == ^user_id and n.group_key == ^group_key)
	+ \|> Repo.delete_all()
	+ end
	+
	+ defp group_pagination(params) do
	cond do
	min_id = Map.get(params, "min_id", Map.get(params, :min_id)) ->
	- query = where(query, [n], n.id > ^min_id)
	+ cursor_filters = [{:gt, min_id}]

	- query =
	+ cursor_filters =
	case Map.get(params, "max_id", Map.get(params, :max_id)) do
	- nil -> query
	- max_id -> where(query, [n], n.id < ^max_id)
	+ nil -> cursor_filters
	+ max_id -> [{:lt, max_id} \| cursor_filters]
	end

	- {query, :asc}
	+ {:asc, cursor_filters}

	since_id = Map.get(params, "since_id", Map.get(params, :since_id)) ->
	- {where(query, [n], n.id > ^since_id), :desc}
	+ {:desc, [{:gt, since_id}]}

	max_id = Map.get(params, "max_id", Map.get(params, :max_id)) ->
	- {where(query, [n], n.id < ^max_id), :desc}
	+ {:desc, [{:lt, max_id}]}

	true ->
	- {query, :desc}
	+ {:desc, []}
	end
	end

	defp grouped_limit(params) do
	params
	\|> Map.get("limit", Map.get(params, :limit, 40))
	\|> parse_limit(40)
	\|> min(80)
	end

	- defp take_grouped_page_notifications(notifications, grouped_types, group_limit) do
	- {notifications, _group_keys} =
	- Enum.reduce_while(notifications, {[], MapSet.new()}, fn notification,
	- {notifications, group_keys} ->
	- group_key = Notification.group_key(notification, grouped_types)
	+ def unread_notification_group_count(user, params \\ %{}) do
	+ grouped_types =
	+ params
	+ \|> Map.get("grouped_types", Map.get(params, :grouped_types))
	+ \|> Notification.normalize_grouped_types()

	- cond do
	- MapSet.member?(group_keys, group_key) ->
	- {:cont, {[notification \| notifications], group_keys}}
	+ limit = unread_count_limit(params)

	- MapSet.size(group_keys) < group_limit ->
	- {:cont, {[notification \| notifications], MapSet.put(group_keys, group_key)}}
	+ user
	+ \|> notifications_query(params)
	+ # The grouped API docs define unread by the notifications marker, not by Pleroma's per-row
	+ # seen flag used by the v1 unread count. Keep this marker-based for Mastodon clients.
	+ \|> restrict_after_marker(notification_marker_last_read_id(user))
	+ \|> notification_group_rows(grouped_types, limit, :desc, [])
	+ \|> length()
	+ end

	- true ->
	- {:halt, {notifications, group_keys}}
	- end
	- end)
	+ defp notification_group_rows(query, grouped_types, group_limit, :desc, cursor_filters) do
	+ query
	+ \|> notification_group_keyed_query(grouped_types)
	+ \|> group_by([n], n.group_key)
	+ \|> apply_group_cursor_filters(cursor_filters)
	+ \|> select([n], %{
	+ group_key: n.group_key,
	+ representative_id: max(n.id),
	+ notifications_count: count(n.id),
	+ page_min_id: min(n.id),
	+ page_max_id: max(n.id),
	+ latest_page_notification_at: max(n.inserted_at)
	+ })
	+ \|> order_by([n], desc: max(n.id))
	+ \|> limit(^group_limit)
	+ \|> Repo.all()
	+ end

	- Enum.reverse(notifications)
	+ defp notification_group_rows(query, grouped_types, group_limit, :asc, cursor_filters) do
	+ query
	+ \|> notification_group_keyed_query(grouped_types)
	+ \|> group_by([n], n.group_key)
	+ \|> apply_group_cursor_filters(cursor_filters)
	+ \|> select([n], %{
	+ group_key: n.group_key,
	+ representative_id: max(n.id),
	+ notifications_count: count(n.id),
	+ page_min_id: min(n.id),
	+ page_max_id: max(n.id),
	+ latest_page_notification_at: max(n.inserted_at)
	+ })
	+ \|> order_by([n], asc: max(n.id))
	+ \|> limit(^group_limit)
	+ \|> Repo.all()
	end

	- def unread_notification_group_count(user, params \\ %{}) do
	- grouped_types = Map.get(params, "grouped_types", Map.get(params, :grouped_types))
	- limit = unread_count_limit(params)
	+ defp apply_group_cursor_filters(query, []), do: query
	+
	+ defp apply_group_cursor_filters(query, [{:gt, id} \| rest]) do
	+ query
	+ \|> having([n], max(n.id) > ^id)
	+ \|> apply_group_cursor_filters(rest)
	+ end
	+
	+ defp apply_group_cursor_filters(query, [{:lt, id} \| rest]) do
	+ query
	+ \|> having([n], max(n.id) < ^id)
	+ \|> apply_group_cursor_filters(rest)
	+ end

	+ defp notification_group_keyed_query(query, grouped_types) do
	+ query
	+ \|> exclude(:preload)
	+ \|> select([n], %{
	+ id: n.id,
	+ inserted_at: n.inserted_at,
	+ group_key:
	+ fragment(
	+ "CASE WHEN ? IS NOT NULL AND ?::text = ANY(?) THEN ? ELSE 'ungrouped-' \|\| ?::text END",
	+ n.group_key,
	+ n.type,
	+ type(^grouped_types, {:array, :string}),
	+ n.group_key,
	+ n.id
	+ )
	+ })
	+ \|> subquery()
	+ end
	+
	+ defp representative_notifications(_query, []), do: []
	+
	+ defp representative_notifications(query, group_rows) do
	+ representative_ids = Enum.map(group_rows, & &1.representative_id)
	+
	+ notifications_by_id =
	+ query
	+ \|> where([n], n.id in ^representative_ids)
	+ \|> Repo.all()
	+ \|> Map.new(&{to_string(&1.id), &1})
	+
	+ group_rows
	+ \|> Enum.map(&Map.get(notifications_by_id, to_string(&1.representative_id)))
	+ \|> Enum.filter(& &1)
	+ end
	+
	+ defp notification_group_counts(group_rows) do
	+ Map.new(group_rows, &{&1.group_key, &1.notifications_count})
	+ end
	+
	+ defp notification_group_bounds(group_rows) do
	+ Map.new(group_rows, fn row ->
	+ {row.group_key,
	+ %{
	+ page_min_id: row.page_min_id,
	+ page_max_id: row.page_max_id,
	+ latest_page_notification_at: row.latest_page_notification_at
	+ }}
	+ end)
	+ end
	+
	+ defp notification_group_sample(user, _params, "ungrouped-" <> notification_id) do
	+ case Notification.get(user, notification_id) do
	+ {:ok, notification} -> [notification]
	+ _ -> []
	+ end
	+ end
	+
	+ defp notification_group_sample(user, params, group_key) do
	user
	- \|> notifications_query(params)
	- \|> where([n], n.seen == false)
	+ \|> notification_group_query(group_key, params)
	\|> order_by([n], desc: n.id)
	- \|> limit(^limit)
	+ \|> limit(^@notification_group_sample_limit)
	\|> Repo.all()
	- \|> Notification.group_notifications(grouped_types)
	- \|> length()
	end

	+ defp notification_group_metadata(user, "ungrouped-" <> notification_id, _params) do
	+ case Notification.get(user, notification_id) do
	+ {:ok, notification} ->
	+ %{
	+ notifications_count: 1,
	+ page_min_id: notification.id,
	+ page_max_id: notification.id,
	+ latest_page_notification_at: notification.inserted_at
	+ }
	+
	+ _ ->
	+ nil
	+ end
	+ end
	+
	+ defp notification_group_metadata(user, group_key, params) do
	+ user
	+ \|> notification_group_query(group_key, params)
	+ \|> exclude(:preload)
	+ \|> select([n], %{
	+ notifications_count: count(n.id),
	+ page_min_id: min(n.id),
	+ page_max_id: max(n.id),
	+ latest_page_notification_at: max(n.inserted_at)
	+ })
	+ \|> Repo.one()
	+ \|> case do
	+ %{notifications_count: 0} -> nil
	+ metadata -> metadata
	+ end
	+ end
	+
	+ defp notification_group_query(user, group_key, params) do
	+ user
	+ \|> notifications_query(params)
	+ \|> where([n], n.group_key == ^group_key)
	+ end
	+
	+ defp notification_marker_last_read_id(user) do
	+ Marker
	+ \|> where([m], m.user_id == ^user.id and m.timeline == "notifications")
	+ \|> select([m], m.last_read_id)
	+ \|> Repo.one()
	+ end
	+
	+ defp restrict_after_marker(query, last_read_id)
	+ when is_binary(last_read_id) and last_read_id != "" do
	+ where(query, [n], n.id > ^last_read_id)
	+ end
	+
	+ defp restrict_after_marker(query, _last_read_id), do: query
	+
	defp notifications_query(user, params) do
	options = notification_options(user, params)

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

	defp notification_options(user, params) do
	options =
	params
	\|> cast_params()
	\|> Map.update(:include_types, [], fn include_types -> include_types end)

	if ("pleroma:report" not in options.include_types and
	User.privileged?(user, :reports_manage_reports)) 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
	end

	defp unread_count_limit(params) do
	params
	\|> Map.get("limit", Map.get(params, :limit, 100))
	\|> parse_limit(100)
	\|> min(1000)
	end

	defp parse_limit(limit, _default) when is_integer(limit) and limit > 0, do: limit

	defp parse_limit(limit, default) when is_binary(limit) do
	case Integer.parse(limit) do
	{limit, _} when limit > 0 -> limit
	_ -> default
	end
	end

	defp parse_limit(_, default), do: default

	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},
	grouped_types: {:array, :string},
	limit: :integer,
	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 466073853..33d4b2924 100644
	--- a/lib/pleroma/web/mastodon_api/views/notification_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	@@ -1,289 +1,321 @@
	# 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("grouped_index.json", %{notifications: notifications} = opts) do
	grouped_types = Notification.normalize_grouped_types(opts[:grouped_types])

	opts
	\|> Map.delete(:notifications)
	\|> Map.put(
	:notification_groups,
	Notification.group_notifications(notifications, grouped_types)
	)
	\|> then(&render("grouped_index.json", &1))
	end

	def render(
	"grouped_index.json",
	%{notification_groups: notification_groups, for: reading_user} = opts
	) do
	grouped_types = Notification.normalize_grouped_types(opts[:grouped_types])
	notification_group_counts = Map.get(opts, :notification_group_counts, %{})
	+ notification_group_bounds = Map.get(opts, :notification_group_bounds, %{})
	+ include_page_metadata = Map.get(opts, :include_page_metadata, true)

	statuses =
	notification_groups
	\|> Enum.map(&List.first/1)
	\|> Enum.map(&render("show.json", %{notification: &1, for: reading_user}))
	\|> Enum.map(& &1[:status])
	\|> Enum.filter(& &1)
	\|> Enum.uniq_by(& &1[:id])

	actors =
	notification_groups
	\|> List.flatten()
	\|> notification_actors()

	%{
	accounts: AccountView.render("index.json", %{users: actors, for: reading_user}),
	statuses: statuses,
	notification_groups:
	Enum.map(
	notification_groups,
	- &render_group(&1, reading_user, grouped_types, notification_group_counts)
	+ &render_group(
	+ &1,
	+ reading_user,
	+ grouped_types,
	+ notification_group_counts,
	+ notification_group_bounds,
	+ include_page_metadata
	+ )
	)
	}
	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: Notification.group_key(notification),
	type: notification.type,
	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
	type when type in ["mention", "status", "poll"] ->
	put_status(response, activity, reading_user, status_render_opts)

	type when type in ["favourite", "reblog", "update"] ->
	put_status(response, parent_activity_fn.(), reading_user, status_render_opts)

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

	"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 put_report(response, activity) do
	report_render = ReportView.render("show.json", Report.extract_report_info(activity))

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

	defp render_group(
	[%Notification{} = notification \| _] = notifications,
	_reading_user,
	grouped_types,
	- notification_group_counts
	+ notification_group_counts,
	+ notification_group_bounds,
	+ include_page_metadata
	) do
	latest_notification = List.first(notifications)
	oldest_notification = List.last(notifications)
	status_activity = status_activity_for_group(notifications, grouped_types)
	group_key = Notification.group_key(notification, grouped_types)
	+ bounds = Map.get(notification_group_bounds, group_key, %{})

	response = %{
	group_key: group_key,
	notifications_count: Map.get(notification_group_counts, group_key, length(notifications)),
	type: notification.type,
	- most_recent_notification_id: to_string(latest_notification.id),
	- page_min_id: to_string(oldest_notification.id),
	- page_max_id: to_string(latest_notification.id),
	- latest_page_notification_at: CommonAPI.Utils.to_masto_date(latest_notification.inserted_at),
	+ most_recent_notification_id:
	+ bounds
	+ \|> Map.get(:page_max_id, latest_notification.id)
	+ \|> to_string(),
	sample_account_ids:
	notifications
	\|> notification_actors()
	\|> Enum.map(&to_string(&1.id))
	}

	+ response =
	+ if include_page_metadata do
	+ Map.merge(response, %{
	+ page_min_id:
	+ bounds
	+ \|> Map.get(:page_min_id, oldest_notification.id)
	+ \|> to_string(),
	+ page_max_id:
	+ bounds
	+ \|> Map.get(:page_max_id, latest_notification.id)
	+ \|> to_string(),
	+ latest_page_notification_at:
	+ bounds
	+ \|> Map.get(:latest_page_notification_at, latest_notification.inserted_at)
	+ \|> CommonAPI.Utils.to_masto_date()
	+ })
	+ else
	+ response
	+ end
	+
	if status_activity do
	Map.put(response, :status_id, to_string(status_activity.id))
	else
	response
	end
	end

	defp status_activity_for_group([%Notification{} = notification \| _], grouped_types) do
	status_activity_for(notification, grouped_types)
	end

	defp status_activity_for(%Notification{type: type, activity: activity}, _grouped_types)
	when type in ["mention", "status", "poll"] do
	activity
	end

	defp status_activity_for(%Notification{type: type} = notification, grouped_types)
	when type in ["favourite", "reblog"] do
	group_key = Notification.group_key(notification, grouped_types)

	case String.split(group_key, "-", parts: 3) do
	[^type, activity_id, _bucket] ->
	case Activity.create_by_id_with_object(activity_id) do
	%Activity{} = activity -> activity
	_ -> parent_status_activity(notification.activity)
	end

	_ ->
	parent_status_activity(notification.activity)
	end
	end

	defp status_activity_for(%Notification{type: type, activity: activity}, _grouped_types)
	when type in ["update", "pleroma:emoji_reaction"] do
	parent_status_activity(activity)
	end

	defp status_activity_for(_, _grouped_types), do: nil

	defp parent_status_activity(activity) do
	Activity.get_create_by_object_ap_id(object_id_for(activity))
	end

	defp notification_actors(notifications) do
	notifications
	\|> Enum.map(&User.get_cached_by_ap_id(&1.activity.data["actor"]))
	\|> Enum.filter(& &1)
	\|> Enum.uniq_by(& &1.id)
	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/priv/repo/migrations/20260523070000_add_group_key_to_notifications.exs b/priv/repo/migrations/20260523070000_add_group_key_to_notifications.exs
	new file mode 100644
	index 000000000..7c7d529e0
	--- /dev/null
	+++ b/priv/repo/migrations/20260523070000_add_group_key_to_notifications.exs
	@@ -0,0 +1,15 @@
	+defmodule Pleroma.Repo.Migrations.AddGroupKeyToNotifications do
	+ use Ecto.Migration
	+
	+ def change do
	+ alter table(:notifications) do
	+ add(:group_key, :string)
	+ end
	+
	+ create_if_not_exists(
	+ index(:notifications, [:user_id, :group_key, "id desc nulls last"],
	+ where: "group_key IS NOT NULL"
	+ )
	+ )
	+ 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 1d3a9e966..e9c521d6b 100644
	--- a/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs
	+++ b/test/pleroma/web/mastodon_api/controllers/notification_controller_test.exs
	@@ -1,886 +1,1021 @@
	# 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
	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[]=pleroma:report")
	\|> json_response_and_validate_schema(200)

	assert [_] = result
	end

	test "Pleroma: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
	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, _, _, %{data: %{"state" => "accept"}}} = CommonAPI.follow(other_user, user)
	{:ok, _, _, %{data: %{"state" => "accept"}}} = CommonAPI.follow(user, other_user)

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

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

	{:ok, unlisted_activity} =
	CommonAPI.post(other_user, %{status: ".", visibility: "unlisted"})

	{:ok, private_activity} = CommonAPI.post(other_user, %{status: ".", visibility: "private"})

	{:ok, _} = CommonAPI.favorite(public_activity.id, user)
	{:ok, _} = CommonAPI.favorite(direct_activity.id, user)
	{:ok, _} = CommonAPI.favorite(unlisted_activity.id, user)
	{:ok, _} = CommonAPI.favorite(private_activity.id, user)

	activity_ids =
	conn
	\|> 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

	describe "GET /api/v2/notifications" do
	test "groups favourite notifications for the same status" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user1 = insert(:user)
	other_user2 = insert(:user)

	{:ok, status} = CommonAPI.post(user, %{status: "hello"})
	{:ok, _} = CommonAPI.favorite(status.id, other_user1)
	{:ok, _} = CommonAPI.favorite(status.id, other_user2)

	- notification_ids =
	- Notification
	- \|> Repo.all()
	- \|> Enum.map(&to_string(&1.id))
	+ notifications = Repo.all(Notification)
	+ notification_ids = Enum.map(notifications, &to_string(&1.id))
	+ assert [persisted_group_key] = notifications \|> Enum.map(& &1.group_key) \|> Enum.uniq()
	+ assert is_binary(persisted_group_key)

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

	assert [%{"id" => account_id1}, %{"id" => account_id2}] = result["accounts"]
	assert account_id1 in [other_user1.id, other_user2.id]
	assert account_id2 in [other_user1.id, other_user2.id]
	assert [%{"id" => status_id}] = result["statuses"]
	assert status_id == status.id

	assert [group] = result["notification_groups"]
	assert group["type"] == "favourite"
	assert group["notifications_count"] == 2
	assert group["status_id"] == status.id
	assert group["most_recent_notification_id"] in notification_ids
	assert group["page_min_id"] in notification_ids
	assert group["page_max_id"] in notification_ids
	assert group["latest_page_notification_at"]
	assert Enum.sort(group["sample_account_ids"]) == Enum.sort([other_user1.id, other_user2.id])
	group_key = group["group_key"]
	+ assert group_key == persisted_group_key

	assert [%{"group_key" => ^group_key}, %{"group_key" => ^group_key}] =
	conn
	\|> get("/api/v1/notifications")
	\|> json_response_and_validate_schema(200)

	assert %{"notification_groups" => [shown_group]} =
	conn
	\|> get("/api/v2/notifications/#{group_key}")
	\|> json_response_and_validate_schema(200)

	assert shown_group["group_key"] == group_key
	assert shown_group["notifications_count"] == 2
	+ refute Map.has_key?(shown_group, "page_min_id")
	+ refute Map.has_key?(shown_group, "page_max_id")
	+ refute Map.has_key?(shown_group, "latest_page_notification_at")
	end

	test "round-trips ungrouped group keys when grouped_types excludes a type" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user = insert(:user)

	{:ok, status} = CommonAPI.post(user, %{status: "hello"})
	{:ok, _} = CommonAPI.favorite(status.id, other_user)

	%{"notification_groups" => [%{"group_key" => "ungrouped-" <> _ = group_key}]} =
	conn
	\|> get("/api/v2/notifications?grouped_types[]=reblog")
	\|> json_response_and_validate_schema(200)

	assert %{
	"notification_groups" => [%{"group_key" => ^group_key, "notifications_count" => 1}]
	} =
	conn
	\|> get("/api/v2/notifications/#{group_key}")
	\|> json_response_and_validate_schema(200)
	end

	+ test "keeps legacy notifications without persisted group keys ungrouped" do
	+ %{user: user, conn: conn} = oauth_access(["read:notifications"])
	+ other_user1 = insert(:user)
	+ other_user2 = insert(:user)
	+
	+ {:ok, status} = CommonAPI.post(user, %{status: "hello"})
	+ {:ok, favorite1} = CommonAPI.favorite(status.id, other_user1)
	+ {:ok, favorite2} = CommonAPI.favorite(status.id, other_user2)
	+
	+ notification_ids =
	+ [favorite1, favorite2]
	+ \|> Enum.map(&get_notification_id_by_activity/1)
	+
	+ Repo.update_all(Notification, set: [group_key: nil])
	+
	+ expected_group_keys = Enum.map(notification_ids, &"ungrouped-#{&1}")
	+
	+ assert [%{"group_key" => group_key1}, %{"group_key" => group_key2}] =
	+ conn
	+ \|> get("/api/v1/notifications")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert Enum.sort([group_key1, group_key2]) == Enum.sort(expected_group_keys)
	+
	+ %{"notification_groups" => groups} =
	+ conn
	+ \|> get("/api/v2/notifications")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert Enum.sort(Enum.map(groups, & &1["group_key"])) == Enum.sort(expected_group_keys)
	+ assert Enum.all?(groups, &(&1["notifications_count"] == 1))
	+
	+ group_key = List.first(expected_group_keys)
	+
	+ assert %{
	+ "notification_groups" => [%{"group_key" => ^group_key, "notifications_count" => 1}]
	+ } =
	+ conn
	+ \|> get("/api/v2/notifications/#{group_key}")
	+ \|> json_response_and_validate_schema(200)
	+ end
	+
	test "paginates notification groups instead of raw notifications" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user1 = insert(:user)
	other_user2 = insert(:user)
	other_user3 = insert(:user)

	{:ok, older_status} = CommonAPI.post(user, %{status: "older"})
	{:ok, _} = CommonAPI.favorite(older_status.id, other_user3)

	{:ok, newer_status} = CommonAPI.post(user, %{status: "newer"})
	{:ok, _} = CommonAPI.favorite(newer_status.id, other_user1)
	{:ok, _} = CommonAPI.favorite(newer_status.id, other_user2)
	older_status_id = older_status.id
	newer_status_id = newer_status.id

	%{"notification_groups" => groups} =
	conn
	\|> get("/api/v2/notifications?limit=2")
	\|> json_response_and_validate_schema(200)

	assert [
	%{"status_id" => ^newer_status_id, "notifications_count" => 2},
	%{"status_id" => ^older_status_id, "notifications_count" => 1}
	] = groups
	end

	+ test "uses group-level cursors when paginating notification groups" do
	+ %{user: user, conn: conn} = oauth_access(["read:notifications"])
	+ other_user1 = insert(:user)
	+ other_user2 = insert(:user)
	+ other_user3 = insert(:user)
	+
	+ {:ok, older_status} = CommonAPI.post(user, %{status: "older"})
	+ {:ok, _} = CommonAPI.favorite(older_status.id, other_user3)
	+
	+ {:ok, newer_status} = CommonAPI.post(user, %{status: "newer"})
	+ {:ok, _} = CommonAPI.favorite(newer_status.id, other_user1)
	+ {:ok, _} = CommonAPI.favorite(newer_status.id, other_user2)
	+ older_status_id = older_status.id
	+ newer_status_id = newer_status.id
	+
	+ assert %{
	+ "notification_groups" => [
	+ %{
	+ "status_id" => ^newer_status_id,
	+ "notifications_count" => 2,
	+ "most_recent_notification_id" => cursor
	+ }
	+ ]
	+ } =
	+ conn
	+ \|> get("/api/v2/notifications?limit=1")
	+ \|> json_response_and_validate_schema(200)
	+
	+ assert %{
	+ "notification_groups" => [
	+ %{"status_id" => ^older_status_id, "notifications_count" => 1}
	+ ]
	+ } =
	+ conn
	+ \|> get("/api/v2/notifications?limit=1&max_id=#{cursor}")
	+ \|> json_response_and_validate_schema(200)
	+ end
	+
	test "returns total notification count for a partially represented group" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user1 = insert(:user)
	other_user2 = insert(:user)
	other_user3 = insert(:user)

	{:ok, grouped_status} = CommonAPI.post(user, %{status: "grouped"})
	{:ok, _} = CommonAPI.favorite(grouped_status.id, other_user1)

	{:ok, other_status} = CommonAPI.post(user, %{status: "other"})
	{:ok, _} = CommonAPI.favorite(other_status.id, other_user3)
	{:ok, _} = CommonAPI.favorite(grouped_status.id, other_user2)
	grouped_status_id = grouped_status.id

	assert %{
	"notification_groups" => [
	%{"status_id" => ^grouped_status_id, "notifications_count" => 2}
	]
	} =
	conn
	\|> get("/api/v2/notifications?limit=1")
	\|> json_response_and_validate_schema(200)
	end

	test "counts unread notification groups" do
	%{user: user, conn: conn} = oauth_access(["read:notifications"])
	other_user1 = insert(:user)
	other_user2 = insert(:user)
	mentioner = insert(:user)

	{:ok, status} = CommonAPI.post(user, %{status: "hello"})
	{:ok, _} = CommonAPI.favorite(status.id, other_user1)
	{:ok, _} = CommonAPI.favorite(status.id, other_user2)
	{:ok, _} = CommonAPI.post(mentioner, %{status: "hi @#{user.nickname}"})

	assert %{"count" => 2} =
	conn
	\|> get("/api/v2/notifications/unread_count")
	\|> json_response_and_validate_schema(200)
	end

	+ test "counts unread notification groups newer than the notification marker" do
	+ %{user: user, conn: conn} = oauth_access(["read:notifications"])
	+ other_user = insert(:user)
	+ mentioner = insert(:user)
	+
	+ {:ok, status} = CommonAPI.post(user, %{status: "older"})
	+ {:ok, favorite_activity} = CommonAPI.favorite(status.id, other_user)
	+ marker_id = get_notification_id_by_activity(favorite_activity)
	+
	+ {:ok, _} = CommonAPI.post(mentioner, %{status: "newer @#{user.nickname}"})
	+
	+ {:ok, _} =
	+ Pleroma.Marker.upsert(user, %{"notifications" => %{"last_read_id" => marker_id}})
	+
	+ assert %{"count" => 1} =
	+ conn
	+ \|> get("/api/v2/notifications/unread_count")
	+ \|> json_response_and_validate_schema(200)
	+ end
	+
	+ test "does not preserve stale cursor params in grouped notification link headers" do
	+ %{user: user, conn: conn} = oauth_access(["read:notifications"])
	+ other_user = insert(:user)
	+
	+ {:ok, activity1} = CommonAPI.post(other_user, %{status: "one @#{user.nickname}"})
	+ {:ok, _activity2} = CommonAPI.post(other_user, %{status: "two @#{user.nickname}"})
	+ {:ok, activity3} = CommonAPI.post(other_user, %{status: "three @#{user.nickname}"})
	+
	+ notification1_id = get_notification_id_by_activity(activity1)
	+ notification3_id = get_notification_id_by_activity(activity3)
	+
	+ conn = get(conn, "/api/v2/notifications?since_id=#{notification1_id}&limit=1")
	+
	+ assert [link_header] = get_resp_header(conn, "link")
	+ assert link_header =~ ~r/max_id=#{notification3_id}/
	+ refute link_header =~ "since_id="
	+ end
	+
	test "lists accounts from and dismisses a notification group" do
	%{user: user, conn: conn} = oauth_access(["read:notifications", "write:notifications"])
	- other_user1 = insert(:user)
	- other_user2 = insert(:user)
	+ other_users = insert_list(9, :user)

	{:ok, status} = CommonAPI.post(user, %{status: "hello"})
	- {:ok, _} = CommonAPI.favorite(status.id, other_user1)
	- {:ok, _} = CommonAPI.favorite(status.id, other_user2)

	- %{"notification_groups" => [%{"group_key" => group_key}]} =
	+ Enum.each(other_users, fn other_user ->
	+ {:ok, _} = CommonAPI.favorite(status.id, other_user)
	+ end)
	+
	+ %{
	+ "notification_groups" => [
	+ %{
	+ "group_key" => group_key,
	+ "notifications_count" => 9,
	+ "sample_account_ids" => sample_account_ids
	+ }
	+ ]
	+ } =
	conn
	\|> get("/api/v2/notifications")
	\|> json_response_and_validate_schema(200)

	+ assert length(sample_account_ids) == 8
	+
	+ %{conn: read_conn} = oauth_access(["read:notifications"], user: user)
	+
	account_ids =
	- conn
	+ read_conn
	\|> get("/api/v2/notifications/#{group_key}/accounts")
	\|> json_response_and_validate_schema(200)
	\|> Enum.map(& &1["id"])

	- assert Enum.sort(account_ids) == Enum.sort([other_user1.id, other_user2.id])
	+ assert Enum.sort(account_ids) == Enum.sort(Enum.map(other_users, & &1.id))

	assert %{} =
	conn
	\|> post("/api/v2/notifications/#{group_key}/dismiss")
	\|> json_response_and_validate_schema(200)

	assert [] = Notification.for_user(user)
	end
	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 aa11ad682..2d0801589 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,377 @@
	# 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)
	+ assert is_binary(notification.group_key)

	expected = %{
	id: to_string(notification.id),
	group_key: Notification.group_key(notification),
	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)
	+ assert is_binary(notification.group_key)

	expected = %{
	id: to_string(notification.id),
	group_key: Notification.group_key(notification),
	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)
	+ assert is_binary(notification.group_key)

	expected = %{
	id: to_string(notification.id),
	group_key: Notification.group_key(notification),
	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%20walking.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%20walking.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",
	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: Notification.group_key(notification),
	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, 12:52 PM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1737080
Default Alt Text: (135 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions