No OneTemporary
Actions

Size

41 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/grouped-notifs-embed.skip b/changelog.d/grouped-notifs-embed.skip
	new file mode 100644
	index 000000000..e69de29bb
	diff --git a/lib/pleroma/web/api_spec/operations/notification_operation.ex b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	index 6c8f7d5e9..740f7645d 100644
	--- a/lib/pleroma/web/api_spec/operations/notification_operation.ex
	+++ b/lib/pleroma/web/api_spec/operations/notification_operation.ex
	@@ -1,400 +1,419 @@
	# 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.Schema
	alias Pleroma.Web.ApiSpec.Schemas.Account
	alias Pleroma.Web.ApiSpec.Schemas.ApiError
	alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
	+ alias Pleroma.Web.ApiSpec.Schemas.ChatMessage
	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" => ["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",
	"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}
	+ status_id: %Schema{type: :string, nullable: true},
	+ target_id: %Schema{
	+ type: :string,
	+ description: "ID of the target account for a move notification"
	+ },
	+ emoji: %Schema{
	+ type: :string,
	+ description: "Emoji used for an emoji reaction notification"
	+ },
	+ emoji_url: %Schema{
	+ type: :string,
	+ nullable: true,
	+ description: "URL of the custom emoji used for an emoji reaction notification"
	+ },
	+ chat_message: ChatMessage,
	+ report: %Schema{
	+ type: :object,
	+ description: "Report embedded in a report notification"
	+ }
	},
	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/mastodon_api/views/notification_view.ex b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	index 33d4b2924..eadfac4a0 100644
	--- a/lib/pleroma/web/mastodon_api/views/notification_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	@@ -1,321 +1,370 @@
	# 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 =
	+ accounts =
	notification_groups
	\|> List.flatten()
	- \|> notification_actors()
	+ \|> notification_accounts()

	%{
	- accounts: AccountView.render("index.json", %{users: actors, for: reading_user}),
	+ accounts: AccountView.render("index.json", %{users: accounts, for: reading_user}),
	statuses: statuses,
	notification_groups:
	Enum.map(
	notification_groups,
	&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,
	+ reading_user,
	grouped_types,
	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:
	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
	+ response =
	+ if status_activity do
	+ Map.put(response, :status_id, to_string(status_activity.id))
	+ else
	+ response
	+ end
	+
	+ put_group_details(response, notification, reading_user)
	+ end
	+
	+ defp put_group_details(response, %Notification{type: "move", activity: activity}, _reading_user) do
	+ case User.get_cached_by_ap_id(activity.data["target"]) do
	+ %User{id: id} -> Map.put(response, :target_id, to_string(id))
	+ _ -> response
	end
	end

	+ defp put_group_details(
	+ response,
	+ %Notification{type: "pleroma:emoji_reaction", activity: activity},
	+ _reading_user
	+ ) do
	+ put_emoji(response, activity)
	+ end
	+
	+ defp put_group_details(
	+ response,
	+ %Notification{type: "pleroma:chat_mention", activity: activity},
	+ reading_user
	+ ) do
	+ put_chat_message(response, activity, reading_user, %{})
	+ end
	+
	+ defp put_group_details(
	+ response,
	+ %Notification{type: "pleroma:report", activity: activity},
	+ _reading_user
	+ ) do
	+ put_report(response, activity)
	+ end
	+
	+ defp put_group_details(response, _notification, _reading_user), do: response
	+
	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 notification_accounts(notifications) do
	+ move_targets =
	+ notifications
	+ \|> Enum.filter(&(&1.type == "move"))
	+ \|> Enum.map(&User.get_cached_by_ap_id(&1.activity.data["target"]))
	+ \|> Enum.filter(& &1)
	+
	+ notifications
	+ \|> notification_actors()
	+ \|> Kernel.++(move_targets)
	+ \|> 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/test/pleroma/web/mastodon_api/views/notification_view_test.exs b/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	index 2d0801589..e6fb31e28 100644
	--- a/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	+++ b/test/pleroma/web/mastodon_api/views/notification_view_test.exs
	@@ -1,377 +1,412 @@
	# 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])
	+
	+ grouped =
	+ NotificationView.render("grouped_index.json", %{
	+ notifications: [notification],
	+ for: recipient
	+ })
	+
	+ assert [group] = grouped.notification_groups
	+ assert group.chat_message == expected.chat_message
	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])
	+
	+ grouped =
	+ NotificationView.render("grouped_index.json", %{
	+ notifications: [notification],
	+ for: follower
	+ })
	+
	+ assert [group] = grouped.notification_groups
	+ assert group.target_id == new_user.id
	+ assert Enum.any?(grouped.accounts, &(&1.id == new_user.id))
	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])
	+
	+ grouped =
	+ NotificationView.render("grouped_index.json", %{notifications: [notification], for: user})
	+
	+ assert [group] = grouped.notification_groups
	+ assert group.emoji == expected.emoji
	+ assert group.emoji_url == expected.emoji_url
	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])
	+
	+ grouped =
	+ NotificationView.render("grouped_index.json", %{
	+ notifications: [notification],
	+ for: moderator_user
	+ })
	+
	+ assert [group] = grouped.notification_groups
	+ assert group.report == expected.report
	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: Sun, Aug 9, 7:42 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723808
Default Alt Text: (41 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions