No OneTemporary
Actions

Authored By

Unknown

Size

87 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/notification.ex b/lib/pleroma/notification.ex
	index 52fd2656b..d142baa8b 100644
	--- a/lib/pleroma/notification.ex
	+++ b/lib/pleroma/notification.ex
	@@ -1,732 +1,760 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Notification do
	use Ecto.Schema

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.FollowingRelationship
	alias Pleroma.Marker
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	import Ecto.Query
	import Ecto.Changeset

	require Logger

	@type t :: %__MODULE__{}

	@include_muted_option :with_muted

	schema "notifications" do
	field(:seen, :boolean, default: false)
	# This is an enum type in the database. If you add a new notification type,
	# remember to add a migration to add it to the `notifications_type` enum
	# as well.
	field(:type, :string)
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	belongs_to(:activity, Activity, type: FlakeId.Ecto.CompatType)

	timestamps()
	end

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

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

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

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

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

	@spec last_read_query(User.t()) :: Ecto.Queryable.t()
	def last_read_query(user) do
	from(q in Pleroma.Notification,
	where: q.user_id == ^user.id,
	where: q.seen == true,
	select: type(q.id, :string),
	limit: 1,
	order_by: [desc: :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') = COALESCE(?->'object'->>'id', ?->>'object')",
	object.data,
	a.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([n, a], a.actor 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([n, a], a.actor 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([n, a], a.actor 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("?->>'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(
	"COALESCE((?->'object')->>'id', ?->>'object')",
	a.data,
	a.data
	) ==
	fragment(
	"COALESCE((?->'object')->>'id', ?->>'object')",
	mutated_activity.data,
	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, %{ids: {_, notification_ids}}} =
	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()

	for_user_query(user)
	\|> where([n], n.id in ^notification_ids)
	\|> Repo.all()
	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()
	\|> case do
	{:ok, %{update: notification}} -> {:ok, notification}
	{:error, :update, changeset, _} -> {:error, changeset}
	end
	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 destroy_multiple_from_types(%{id: user_id}, types) do
	from(n in Notification,
	where: n.user_id == ^user_id,
	where: n.type in ^types
	)
	\|> 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(), keyword()) :: {:ok, [Notification.t()] \| []}
	def create_notifications(activity, options \\ [])

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

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

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

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

	defp do_create_notifications(%Activity{} = activity, options) do
	do_send = Keyword.get(options, :do_send, true)

	{enabled_receivers, disabled_receivers} = get_notified_from_activity(activity)
	potential_receivers = enabled_receivers ++ disabled_receivers

	+ {enabled_subscribers, disabled_subscribers} = get_notified_subscribers_from_activity(activity)
	+ potential_subscribers = (enabled_subscribers ++ disabled_subscribers) -- potential_receivers
	+
	notifications =
	- Enum.map(potential_receivers, fn user ->
	- do_send = do_send && user in enabled_receivers
	- create_notification(activity, user, do_send: do_send)
	- end)
	+ (Enum.map(potential_receivers, fn user ->
	+ do_send = do_send && user in enabled_receivers
	+ create_notification(activity, user, do_send: do_send)
	+ end) ++
	+ Enum.map(potential_subscribers, fn user ->
	+ do_send = do_send && user in enabled_subscribers
	+ create_notification(activity, user, do_send: do_send, 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()

	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
	do_send = Keyword.get(opts, :do_send, true)
	type = Keyword.get(opts, :type, type_from_activity(activity))

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

	if do_send do
	Streamer.stream(["user", "user:notification"], notification)
	Push.send(notification)
	end

	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()), 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"] 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)

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

	{notification_enabled_users, potential_receivers -- notification_enabled_users}
	end

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

	+ def get_notified_subscribers_from_activity(activity, local_only \\ true)
	+
	+ def get_notified_subscribers_from_activity(
	+ %Activity{data: %{"type" => "Create"}} = activity,
	+ local_only
	+ ) do
	+ notification_enabled_ap_ids =
	+ []
	+ \|> Utils.maybe_notify_subscribers(activity)
	+
	+ potential_receivers =
	+ User.get_users_from_set(notification_enabled_ap_ids, local_only: local_only)
	+
	+ notification_enabled_users =
	+ Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
	+
	+ {notification_enabled_users, potential_receivers -- notification_enabled_users}
	+ 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_superusers() \|> Enum.map(fn user -> user.ap_id end)) -- [actor]
	end

	def get_potential_receiver_ap_ids(activity) do
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	- \|> Utils.maybe_notify_subscribers(activity)
	\|> Utils.maybe_notify_followers(activity)
	\|> Enum.uniq()
	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,
	: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?(: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?(follower, user) -> 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?(target_user, activity)
	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
	end
	diff --git a/lib/pleroma/web/api_spec/operations/notification_operation.ex b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	index 7f2336ff6..aa965fabb 100644
	--- a/lib/pleroma/web/api_spec/operations/notification_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	@@ -1,223 +1,225 @@
	# 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()},
	"Include the notifications for activities with the given types"
	),
	Operation.parameter(
	:with_muted,
	:query,
	BooleanLike,
	"Include the notifications from muted users"
	)
	] ++ pagination_params(),
	responses: %{
	200 =>
	Operation.response("Array of notifications", "application/json", %Schema{
	type: :array,
	items: notification()
	}),
	404 => Operation.response("Error", "application/json", ApiError)
	}
	}
	end

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

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

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

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

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

	def notification do
	%Schema{
	title: "Notification",
	description: "Response schema for a notification",
	type: :object,
	properties: %{
	id: %Schema{type: :string},
	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",
	"type" => "mention",
	"created_at" => "2019-11-23T07:49:02.064Z",
	"account" => Account.schema().example,
	"status" => Status.schema().example,
	"pleroma" => %{"is_seen" => false, "is_muted" => false}
	}
	}
	end

	defp notification_type do
	%Schema{
	type: :string,
	enum: [
	"follow",
	"favourite",
	"reblog",
	"mention",
	"pleroma:emoji_reaction",
	"pleroma:chat_mention",
	"pleroma:report",
	"move",
	"follow_request",
	- "poll"
	+ "poll",
	+ "status"
	],
	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
	"""
	}
	end

	defp id_param do
	Operation.parameter(:id, :path, :string, "Notification ID",
	example: "123",
	required: true
	)
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex b/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	index 932bc6423..9209e8ebd 100644
	--- a/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/controllers/notification_controller.ex
	@@ -1,111 +1,112 @@
	# 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.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.Plugs.OAuthScopesPlug

	@oauth_read_actions [:show, :index]

	plug(Pleroma.Web.ApiSpec.CastAndValidate)

	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

	# GET /api/v1/notifications
	def index(conn, %{account_id: account_id} = params) do
	case Pleroma.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)

	index(conn, params)

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

	@default_notification_types ~w{
	mention
	follow
	follow_request
	reblog
	favourite
	move
	pleroma:emoji_reaction
	poll
	+ status
	}
	def index(%{assigns: %{user: user}} = conn, params) do
	params =
	Map.new(params, fn {k, v} -> {to_string(k), v} end)
	\|> Map.put_new("include_types", @default_notification_types)

	notifications = MastodonAPI.get_notifications(user, params)

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

	# GET /api/v1/notifications/:id
	def show(%{assigns: %{user: user}} = conn, %{id: id}) 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(%{assigns: %{user: user}} = conn, %{id: id} = _params) do
	with {:ok, _notif} <- Notification.dismiss(user, id) do
	json(conn, %{})
	else
	{:error, reason} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{"error" => reason})
	end
	end

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

	# DELETE /api/v1/notifications/destroy_multiple
	def destroy_multiple(%{assigns: %{user: user}} = conn, %{ids: ids} = _params) do
	Notification.destroy_multiple(user, ids)
	json(conn, %{})
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/notification_view.ex b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	index 0dc7f3beb..b10b0893c 100644
	--- a/lib/pleroma/web/mastodon_api/views/notification_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	@@ -1,169 +1,172 @@
	# 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.PleromaAPI.Chat.MessageReferenceView

	@parent_types ~w{Like Announce EmojiReact}

	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(& &1.data["object"])
	\|> Activity.create_by_object_ap_id()
	\|> Activity.with_preloaded_object(:left)
	\|> Pleroma.Repo.all()

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

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

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

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

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

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

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

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

	parent_activity_fn = fn ->
	if opts[:parent_activities] do
	Activity.Queries.find_by_object_ap_id(opts[:parent_activities], activity.data["object"])
	else
	Activity.get_create_by_object_ap_id(activity.data["object"])
	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),
	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
	"mention" ->
	put_status(response, activity, reading_user, status_render_opts)

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

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

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

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

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

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

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

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

	defp put_report(response, activity) do
	report_render = ReportView.render("show.json", Report.extract_report_info(activity))

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

	defp put_emoji(response, activity) do
	Map.put(response, :emoji, activity.data["content"])
	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/lib/pleroma/web/push/impl.ex b/lib/pleroma/web/push/impl.ex
	index daf3eeb9e..77bc2941d 100644
	--- a/lib/pleroma/web/push/impl.ex
	+++ b/lib/pleroma/web/push/impl.ex
	@@ -1,195 +1,196 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	require Logger
	import Ecto.Query

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

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

	mastodon_type = notification.type
	gcm_api_key = Application.get_env(:web_push_encryption, :gcm_api_key)
	avatar_url = User.avatar_url(actor)
	object = Object.normalize(activity, fetch: false)
	user = User.get_cached_by_id(user_id)
	direct_conversation_id = Activity.direct_conversation_id(activity, user)

	for subscription <- fetch_subscriptions(user_id),
	Subscription.enabled?(subscription, mastodon_type) do
	%{
	access_token: subscription.token.token,
	notification_id: notification.id,
	notification_type: mastodon_type,
	icon: avatar_url,
	preferred_locale: "en",
	pleroma: %{
	activity_id: notification.activity.id,
	direct_conversation_id: direct_conversation_id
	}
	}
	\|> Map.merge(build_content(notification, actor, object, mastodon_type))
	\|> Jason.encode!()
	\|> push_message(build_sub(subscription), gcm_api_key, subscription)
	end
	\|> (&{:ok, &1}).()
	end

	def perform(_) do
	Logger.warn("Unknown notification type")
	{:error, :unknown_type}
	end

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

	{:ok, %{status: code}} when code in 200..299 ->
	:ok

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

	error ->
	Logger.error("Web Push Notification failed with #{inspect(error)}")
	:error
	end
	end

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

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

	def build_content(notification, actor, object, mastodon_type \\ nil)

	def build_content(
	%{
	user: %{notification_settings: %{hide_notification_contents: true}}
	} = notification,
	_actor,
	_object,
	mastodon_type
	) do
	%{body: format_title(notification, mastodon_type)}
	end

	def build_content(notification, actor, object, mastodon_type) do
	mastodon_type = mastodon_type \|\| notification.type

	%{
	title: format_title(notification, mastodon_type),
	body: format_body(notification, actor, object, mastodon_type)
	}
	end

	def format_body(activity, actor, object, mastodon_type \\ nil)

	def format_body(_activity, actor, %{data: %{"type" => "ChatMessage"} = data}, _) do
	case data["content"] do
	nil -> "@#{actor.nickname}: (Attachment)"
	content -> "@#{actor.nickname}: #{Utils.scrub_html_and_truncate(content, 80)}"
	end
	end

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

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

	def format_body(
	%{activity: %{data: %{"type" => "EmojiReact", "content" => content}}},
	actor,
	_object,
	_mastodon_type
	) do
	"@#{actor.nickname} reacted with #{content}"
	end

	def format_body(
	%{activity: %{data: %{"type" => type}}} = notification,
	actor,
	_object,
	mastodon_type
	)
	when type in ["Follow", "Like"] do
	mastodon_type = mastodon_type \|\| notification.type

	case mastodon_type do
	"follow" -> "@#{actor.nickname} has followed you"
	"follow_request" -> "@#{actor.nickname} has requested to follow you"
	"favourite" -> "@#{actor.nickname} has favorited your post"
	end
	end

	def format_title(activity, mastodon_type \\ nil)

	def format_title(%{activity: %{data: %{"directMessage" => true}}}, _mastodon_type) do
	"New Direct Message"
	end

	def format_title(%{type: type}, mastodon_type) do
	case mastodon_type \|\| type do
	"mention" -> "New Mention"
	+ "status" -> "New Status"
	"follow" -> "New Follower"
	"follow_request" -> "New Follow Request"
	"reblog" -> "New Repeat"
	"favourite" -> "New Favorite"
	"pleroma:chat_mention" -> "New Chat Message"
	"pleroma:emoji_reaction" -> "New Reaction"
	type -> "New #{String.capitalize(type \|\| "event")}"
	end
	end
	end
	diff --git a/priv/repo/migrations/20220319000000_add_status_to_notifications_enum.exs b/priv/repo/migrations/20220319000000_add_status_to_notifications_enum.exs
	new file mode 100644
	index 000000000..62c0afb63
	--- /dev/null
	+++ b/priv/repo/migrations/20220319000000_add_status_to_notifications_enum.exs
	@@ -0,0 +1,50 @@
	+defmodule Pleroma.Repo.Migrations.AddStatusToNotificationsEnum do
	+ use Ecto.Migration
	+
	+ @disable_ddl_transaction true
	+
	+ def up do
	+ """
	+ alter type notification_type add value 'status'
	+ """
	+ \|> execute()
	+ end
	+
	+ def down do
	+ alter table(:notifications) do
	+ modify(:type, :string)
	+ end
	+
	+ """
	+ delete from notifications where type = 'status'
	+ """
	+ \|> execute()
	+
	+ """
	+ drop type if exists notification_type
	+ """
	+ \|> execute()
	+
	+ """
	+ create type notification_type as enum (
	+ 'follow',
	+ 'follow_request',
	+ 'mention',
	+ 'move',
	+ 'pleroma:emoji_reaction',
	+ 'pleroma:chat_mention',
	+ 'reblog',
	+ 'favourite',
	+ 'pleroma:report',
	+ 'poll
	+ )
	+ """
	+ \|> execute()
	+
	+ """
	+ alter table notifications
	+ alter column type type notification_type using (type::notification_type)
	+ """
	+ \|> execute()
	+ end
	+end
	diff --git a/test/pleroma/notification_test.exs b/test/pleroma/notification_test.exs
	index 805764ea4..eea2fcb67 100644
	--- a/test/pleroma/notification_test.exs
	+++ b/test/pleroma/notification_test.exs
	@@ -1,1196 +1,1197 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.NotificationTest do
	use Pleroma.DataCase

	import Pleroma.Factory
	import Mock

	alias Pleroma.FollowingRelationship
	alias Pleroma.Notification
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.Push
	alias Pleroma.Web.Streamer

	describe "create_notifications" do
	test "never returns nil" do
	user = insert(:user)
	other_user = insert(:user, %{invisible: true})

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

	refute {:ok, [nil]} == Notification.create_notifications(activity)
	end

	test "creates a notification for a report" do
	reporting_user = insert(:user)
	reported_user = insert(:user)
	{:ok, moderator_user} = insert(:user) \|> User.admin_api_update(%{is_moderator: true})

	{:ok, activity} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})

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

	assert notification.user_id == moderator_user.id
	assert notification.type == "pleroma:report"
	end

	test "suppresses notification to reporter if reporter is an admin" do
	reporting_admin = insert(:user, is_admin: true)
	reported_user = insert(:user)
	other_admin = insert(:user, is_admin: true)

	{:ok, activity} = CommonAPI.report(reporting_admin, %{account_id: reported_user.id})

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

	refute notification.user_id == reporting_admin.id
	assert notification.user_id == other_admin.id
	assert notification.type == "pleroma:report"
	end

	test "creates a notification for an emoji reaction" do
	user = insert(:user)
	other_user = insert(:user)

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

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

	assert notification.user_id == user.id
	assert notification.type == "pleroma:emoji_reaction"
	end

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

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

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

	notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
	assert notified_ids == [other_user.id, third_user.id]
	assert notification.activity_id == activity.id
	assert notification.type == "mention"
	assert other_notification.activity_id == activity.id

	assert [%Pleroma.Marker{unread_count: 2}] =
	Pleroma.Marker.get_markers(other_user, ["notifications"])
	end

	test "it creates a notification for subscribed users" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

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

	assert notification.user_id == subscriber.id
	+ assert notification.type == "status"
	end

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

	User.subscribe(subscriber, other_user)

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

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

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

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

	test "create_poll_notifications/1" do
	[user1, user2, user3, _, _] = insert_list(5, :user)
	question = insert(:question, user: user1)
	activity = insert(:question_activity, question: question)

	{:ok, _, _} = CommonAPI.vote(user2, question, [0])
	{:ok, _, _} = CommonAPI.vote(user3, question, [1])

	{:ok, notifications} = Notification.create_poll_notifications(activity)

	assert [user2.id, user3.id, user1.id] == Enum.map(notifications, & &1.user_id)
	end

	describe "CommonApi.post/2 notification-related functionality" do
	test_with_mock "creates but does NOT send notification to blocker user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	blocker = insert(:user)
	{:ok, _user_relationship} = User.block(blocker, user)

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

	blocker_id = blocker.id
	assert [%Notification{user_id: ^blocker_id}] = Repo.all(Notification)
	refute called(Push.send(:_))
	end

	test_with_mock "creates but does NOT send notification to notification-muter user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	muter = insert(:user)
	{:ok, _user_relationships} = User.mute(muter, user)

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

	muter_id = muter.id
	assert [%Notification{user_id: ^muter_id}] = Repo.all(Notification)
	refute called(Push.send(:_))
	end

	test_with_mock "creates but does NOT send notification to thread-muter user",
	Push,
	[:passthrough],
	[] do
	user = insert(:user)
	thread_muter = insert(:user)

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

	{:ok, _} = CommonAPI.add_mute(thread_muter, activity)

	{:ok, _same_context_activity} =
	CommonAPI.post(user, %{
	status: "hey-hey-hey @#{thread_muter.nickname}!",
	in_reply_to_status_id: activity.id
	})

	[pre_mute_notification, post_mute_notification] =
	Repo.all(from(n in Notification, where: n.user_id == ^thread_muter.id, order_by: n.id))

	pre_mute_notification_id = pre_mute_notification.id
	post_mute_notification_id = post_mute_notification.id

	assert called(
	Push.send(
	:meck.is(fn
	%Notification{id: ^pre_mute_notification_id} -> true
	_ -> false
	end)
	)
	)

	refute called(
	Push.send(
	:meck.is(fn
	%Notification{id: ^post_mute_notification_id} -> true
	_ -> false
	end)
	)
	)
	end
	end

	describe "create_notification" do
	@tag needs_streamer: true
	test "it creates a notification for user and send to the 'user' and the 'user:notification' stream" do
	%{user: user, token: oauth_token} = oauth_access(["read"])

	task =
	Task.async(fn ->
	{:ok, _topic} = Streamer.get_topic_and_add_socket("user", user, oauth_token)
	assert_receive {:render_with_user, _, _, _}, 4_000
	end)

	task_user_notification =
	Task.async(fn ->
	{:ok, _topic} =
	Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)

	assert_receive {:render_with_user, _, _, _}, 4_000
	end)

	activity = insert(:note_activity)

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

	test "it creates a notification for user if the user blocks the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])
	user = insert(:user)
	{:ok, _user_relationship} = User.block(user, author)

	assert Notification.create_notification(activity, user)
	end

	test "it creates a notification for the user if the user mutes the activity author" do
	muter = insert(:user)
	muted = insert(:user)
	{:ok, _} = User.mute(muter, muted)
	muter = Repo.get(User, muter.id)
	{:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})

	notification = Notification.create_notification(activity, muter)

	assert notification.id
	assert notification.seen
	end

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

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

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

	assert Notification.create_notification(activity, muter)
	end

	test "it creates a notification for an activity from a muted thread" do
	muter = insert(:user)
	other_user = insert(:user)
	{:ok, activity} = CommonAPI.post(muter, %{status: "hey"})
	CommonAPI.add_mute(muter, activity)

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

	notification = Notification.create_notification(activity, muter)

	assert notification.id
	assert notification.seen
	end

	test "it disables notifications from strangers" do
	follower = insert(:user)

	followed =
	insert(:user,
	notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
	)

	{:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
	refute Notification.create_notification(activity, followed)
	end

	test "it doesn't create a notification for user if he is the activity author" do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])

	refute Notification.create_notification(activity, author)
	end

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

	{:ok, _, _, _} = CommonAPI.follow(subscriber, user)
	User.subscribe(subscriber, user)
	{:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
	{:ok, [_notif]} = Notification.create_notifications(status)
	end

	test "it doesn't create subscription notifications if the recipient cannot see the status" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)

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

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it disables notifications from people who are invisible" do
	author = insert(:user, invisible: true)
	user = insert(:user)

	{:ok, status} = CommonAPI.post(author, %{status: "hey @#{user.nickname}"})
	refute Notification.create_notification(status, user)
	end

	test "it doesn't create notifications if content matches with an irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: true)

	{:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})

	assert {:ok, []} == Notification.create_notifications(status)
	end

	test "it creates notifications if content matches with a not irreversible filter" do
	user = insert(:user)
	subscriber = insert(:user)

	User.subscribe(subscriber, user)
	insert(:filter, user: subscriber, phrase: "cofe", hide: false)

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

	assert notification
	refute notification.seen
	end

	test "it creates notifications when someone likes user's status with a filtered word" do
	user = insert(:user)
	other_user = insert(:user)
	insert(:filter, user: user, phrase: "tesla", hide: true)

	{:ok, activity_one} = CommonAPI.post(user, %{status: "wow tesla"})
	{:ok, activity_two} = CommonAPI.favorite(other_user, activity_one.id)

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

	assert notification
	refute notification.seen
	end
	end

	describe "follow / follow_request notifications" do
	test "it creates `follow` notification for approved Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	assert %{type: "follow"} =
	NotificationView.render("show.json", %{
	notification: notification,
	for: followed_user
	})
	end

	test "it creates `follow_request` notification for pending Follow activity" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: true)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	refute FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	render_opts = %{notification: notification, for: followed_user}
	assert %{type: "follow_request"} = NotificationView.render("show.json", render_opts)

	# After request is accepted, the same notification is rendered with type "follow":
	assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)

	notification =
	Repo.get(Notification, notification.id)
	\|> Repo.preload(:activity)

	assert %{type: "follow"} =
	NotificationView.render("show.json", notification: notification, for: followed_user)
	end

	test "it doesn't create a notification for follow-unfollow-follow chains" do
	user = insert(:user)
	followed_user = insert(:user, is_locked: false)

	{:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
	assert FollowingRelationship.following?(user, followed_user)
	assert [notification] = Notification.for_user(followed_user)

	CommonAPI.unfollow(user, followed_user)
	{:ok, _, _, _activity_dupe} = CommonAPI.follow(user, followed_user)

	notification_id = notification.id
	assert [%{id: ^notification_id}] = Notification.for_user(followed_user)
	end

	test "dismisses the notification on follow request rejection" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)
	{:ok, _, _, _follow_activity} = CommonAPI.follow(follower, user)
	assert [_notification] = Notification.for_user(user)
	{:ok, _follower} = CommonAPI.reject_follow_request(follower, user)
	assert [] = Notification.for_user(user)
	end
	end

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

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

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

	assert notification.user_id == other_user.id
	end

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

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

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

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

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

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

	assert notification.user_id == other_user.id
	end

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

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

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

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

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

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

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

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

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

	describe "destroy_multiple_from_types/2" do
	test "clears all notifications of a certain type for a given user" do
	report_activity = insert(:report_activity)
	user1 = insert(:user, is_moderator: true, is_admin: true)
	user2 = insert(:user, is_moderator: true, is_admin: true)
	{:ok, _} = Notification.create_notifications(report_activity)

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

	Notification.destroy_multiple_from_types(user1, ["pleroma:report"])

	assert [%Pleroma.Notification{type: "mention"}] = Notification.for_user(user1)
	assert [%Pleroma.Notification{type: "pleroma:report"}] = Notification.for_user(user2)
	end
	end

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

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

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

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

	assert n2.id > n1.id

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

	[_, read_notification] = Notification.set_read_up_to(other_user, n2.id)

	assert read_notification.activity.object

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

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

	assert %Pleroma.Marker{} =
	m =
	Pleroma.Repo.get_by(
	Pleroma.Marker,
	user_id: other_user.id,
	timeline: "notifications"
	)

	assert m.last_read_id == to_string(n2.id)
	end
	end

	describe "for_user_since/2" do
	defp days_ago(days) do
	NaiveDateTime.add(
	NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
	-days * 60 * 60 * 24,
	:second
	)
	end

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

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

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

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

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

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

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

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

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

	{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

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

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

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

	{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert other_user in enabled_receivers
	end

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

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

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

	{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert other_user not in enabled_receivers
	end

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

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

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

	{enabled_receivers, _disabled_receivers} =
	Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it only notifies the post's author in likes" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	{:ok, like_data, _} = Builder.like(third_user, activity_one.object)

	{:ok, like, _} =
	like_data
	\|> Map.put("to", [other_user.ap_id \| like_data["to"]])
	\|> ActivityPub.persist(local: true)

	{enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(like)

	assert other_user not in enabled_receivers
	end

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

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

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

	{enabled_receivers, _disabled_receivers} =
	Notification.get_notified_from_activity(activity_two)

	assert other_user not in enabled_receivers
	end

	test "it returns blocking recipient in disabled recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationship} = User.block(other_user, user)

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

	{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	assert [other_user] == disabled_receivers
	end

	test "it returns notification-muting recipient in disabled recipients list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _user_relationships} = User.mute(other_user, user)

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

	{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	assert [other_user] == disabled_receivers
	end

	test "it returns thread-muting recipient in disabled recipients list" do
	user = insert(:user)
	other_user = insert(:user)

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

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

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

	{enabled_receivers, disabled_receivers} =
	Notification.get_notified_from_activity(same_context_activity)

	assert [other_user] == disabled_receivers
	refute other_user in enabled_receivers
	end

	test "it returns non-following domain-blocking recipient in disabled recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)

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

	{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [] == enabled_receivers
	assert [other_user] == disabled_receivers
	end

	test "it returns following domain-blocking recipient in enabled recipients list" do
	blocked_domain = "blocked.domain"
	user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
	other_user = insert(:user)

	{:ok, other_user} = User.block_domain(other_user, blocked_domain)
	{:ok, other_user, user} = User.follow(other_user, user)

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

	{enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)

	assert [other_user] == enabled_receivers
	assert [] == disabled_receivers
	end
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	remote_user_url = remote_user.ap_id

	Tesla.Mock.mock(fn
	%{method: :get, url: ^remote_user_url} ->
	%Tesla.Env{status: 404, body: ""}
	end)

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

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

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

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

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

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

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

	describe "for_user" do
	setup do
	user = insert(:user)

	{:ok, %{user: user}}
	end

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

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

	[notification] = Notification.for_user(user)

	assert notification.activity.object
	assert notification.seen
	end

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

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

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

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

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

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

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

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

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

	test "it returns notifications for domain-blocked but followed user" do
	user = insert(:user)
	blocked = insert(:user, ap_id: "http://some-domain.com")

	{:ok, user} = User.block_domain(user, "some-domain.com")
	{:ok, _, _} = User.follow(user, blocked)

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

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

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

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

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

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

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

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

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

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

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

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

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

	assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
	end

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

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

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

	test "it doesn't return notifications about mentions with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(another_user, %{status: "@#{user.nickname} got cofe?"})

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

	test "it returns notifications about mentions with not hidden filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "test", hide: false)
	another_user = insert(:user)

	{:ok, _} = CommonAPI.post(another_user, %{status: "@#{user.nickname} test"})

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

	test "it returns notifications about favorites with filtered word", %{user: user} do
	insert(:filter, user: user, phrase: "cofe", hide: true)
	another_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{status: "Give me my cofe!"})
	{:ok, _} = CommonAPI.favorite(another_user, activity.id)

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

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 6:34 AM (23 h, 11 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1799694
Default Alt Text: (87 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions