No OneTemporary
Actions

Authored By

Unknown

Size

21 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/chat_message_reference.ex b/lib/pleroma/chat_message_reference.ex
	index e9ca3dfe8..6808d1365 100644
	--- a/lib/pleroma/chat_message_reference.ex
	+++ b/lib/pleroma/chat_message_reference.ex
	@@ -1,80 +1,87 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ChatMessageReference do
	@moduledoc """
	A reference that builds a relation between an AP chat message that a user can see and whether it has been seen
	by them, or should be displayed to them. Used to build the chat view that is presented to the user.
	"""

	use Ecto.Schema

	alias Pleroma.Chat
	alias Pleroma.Object
	alias Pleroma.Repo

	import Ecto.Changeset
	import Ecto.Query

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

	schema "chat_message_references" do
	belongs_to(:object, Object)
	belongs_to(:chat, Chat)

	field(:seen, :boolean, default: false)

	timestamps()
	end

	def changeset(struct, params) do
	struct
	\|> cast(params, [:object_id, :chat_id, :seen])
	\|> validate_required([:object_id, :chat_id, :seen])
	end

	def get_by_id(id) do
	__MODULE__
	\|> Repo.get(id)
	\|> Repo.preload(:object)
	end

	def delete(cm_ref) do
	cm_ref
	\|> Repo.delete()
	end

	def delete_for_object(%{id: object_id}) do
	from(cr in __MODULE__,
	where: cr.object_id == ^object_id
	)
	\|> Repo.delete_all()
	end

	def for_chat_and_object(%{id: chat_id}, %{id: object_id}) do
	__MODULE__
	\|> Repo.get_by(chat_id: chat_id, object_id: object_id)
	\|> Repo.preload(:object)
	end

	def for_chat_query(chat) do
	from(cr in __MODULE__,
	where: cr.chat_id == ^chat.id,
	order_by: [desc: :id],
	preload: [:object]
	)
	end

	+ def last_message_for_chat(chat) do
	+ chat
	+ \|> for_chat_query()
	+ \|> limit(1)
	+ \|> Repo.one()
	+ end
	+
	def create(chat, object, seen) do
	params = %{
	chat_id: chat.id,
	object_id: object.id,
	seen: seen
	}

	%__MODULE__{}
	\|> changeset(params)
	\|> Repo.insert()
	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 af15bba48..2ae82eb2d 100644
	--- a/lib/pleroma/web/mastodon_api/views/notification_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/notification_view.ex
	@@ -1,161 +1,163 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 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.ChatMessageReference
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.StatusView
	- alias Pleroma.Web.PleromaAPI.ChatMessageView
	+ alias Pleroma.Web.PleromaAPI.ChatMessageReferenceView

	@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"]))

	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]}

	with %{id: _} = account <-
	AccountView.render(
	"show.json",
	%{user: actor, for: reading_user}
	) do
	response = %{
	id: to_string(notification.id),
	type: notification.type,
	created_at: CommonAPI.Utils.to_masto_date(notification.inserted_at),
	account: account,
	pleroma: %{
	is_seen: notification.seen
	}
	}

	case notification.type do
	"mention" ->
	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, %{})

	"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)

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

	_ ->
	nil
	end
	else
	_ -> nil
	end
	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)
	author = User.get_cached_by_ap_id(object.data["actor"])
	chat = Pleroma.Chat.get(reading_user.id, author.ap_id)
	- render_opts = Map.merge(opts, %{object: object, for: reading_user, chat: chat})
	- chat_message_render = ChatMessageView.render("show.json", render_opts)
	+ cm_ref = ChatMessageReference.for_chat_and_object(chat, object)
	+ render_opts = Map.merge(opts, %{for: reading_user, chat_message_reference: cm_ref})
	+ chat_message_render = ChatMessageReferenceView.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/pleroma_api/views/chat_view.ex b/lib/pleroma/web/pleroma_api/views/chat_view.ex
	index 223b64987..331c1d282 100644
	--- a/lib/pleroma/web/pleroma_api/views/chat_view.ex
	+++ b/lib/pleroma/web/pleroma_api/views/chat_view.ex
	@@ -1,32 +1,34 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ChatView do
	use Pleroma.Web, :view

	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	- alias Pleroma.Web.PleromaAPI.ChatMessageView
	+ alias Pleroma.Web.PleromaAPI.ChatMessageReferenceView

	def render("show.json", %{chat: %Chat{} = chat} = opts) do
	recipient = User.get_cached_by_ap_id(chat.recipient)

	- last_message = opts[:message] \|\| Chat.last_message_for_chat(chat)
	+ last_message = opts[:last_message] \|\| ChatMessageReference.last_message_for_chat(chat)

	%{
	id: chat.id \|> to_string(),
	account: AccountView.render("show.json", Map.put(opts, :user, recipient)),
	unread: chat.unread,
	last_message:
	- last_message && ChatMessageView.render("show.json", chat: chat, object: last_message),
	+ last_message &&
	+ ChatMessageReferenceView.render("show.json", chat_message_reference: last_message),
	updated_at: Utils.to_masto_date(chat.updated_at)
	}
	end

	def render("index.json", %{chats: chats}) do
	render_many(chats, __MODULE__, "show.json")
	end
	end
	diff --git a/lib/pleroma/web/views/streamer_view.ex b/lib/pleroma/web/views/streamer_view.ex
	index 5e953d770..616e0c4f2 100644
	--- a/lib/pleroma/web/views/streamer_view.ex
	+++ b/lib/pleroma/web/views/streamer_view.ex
	@@ -1,85 +1,91 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.StreamerView do
	use Pleroma.Web, :view

	alias Pleroma.Activity
	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.User
	alias Pleroma.Web.MastodonAPI.NotificationView

	def render("chat_update.json", object, user, recipients) do
	chat = Chat.get(user.id, hd(recipients -- [user.ap_id]))

	+ # Explicitly giving the cmr for the object here, so we don't accidentally
	+ # send a later 'last_message' that was inserted between inserting this and
	+ # streaming it out
	+ cm_ref = ChatMessageReference.for_chat_and_object(chat, object)
	+
	representation =
	Pleroma.Web.PleromaAPI.ChatView.render(
	"show.json",
	- %{message: object, chat: chat}
	+ %{last_message: cm_ref, chat: chat}
	)

	%{
	event: "pleroma:chat_update",
	payload:
	representation
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end

	def render("update.json", %Activity{} = activity, %User{} = user) do
	%{
	event: "update",
	payload:
	Pleroma.Web.MastodonAPI.StatusView.render(
	"show.json",
	activity: activity,
	for: user
	)
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end

	def render("notification.json", %Notification{} = notify, %User{} = user) do
	%{
	event: "notification",
	payload:
	NotificationView.render(
	"show.json",
	%{notification: notify, for: user}
	)
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end

	def render("update.json", %Activity{} = activity) do
	%{
	event: "update",
	payload:
	Pleroma.Web.MastodonAPI.StatusView.render(
	"show.json",
	activity: activity
	)
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end

	def render("conversation.json", %Participation{} = participation) do
	%{
	event: "conversation",
	payload:
	Pleroma.Web.MastodonAPI.ConversationView.render("participation.json", %{
	participation: participation,
	for: participation.user
	})
	\|> Jason.encode!()
	}
	\|> Jason.encode!()
	end
	end
	diff --git a/test/web/mastodon_api/views/notification_view_test.exs b/test/web/mastodon_api/views/notification_view_test.exs
	index 384fe7253..c5691341a 100644
	--- a/test/web/mastodon_api/views/notification_view_test.exs
	+++ b/test/web/mastodon_api/views/notification_view_test.exs
	@@ -1,209 +1,212 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	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.ChatMessageView
	+ alias Pleroma.Web.PleromaAPI.ChatMessageReferenceView
	import Pleroma.Factory

	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)
	chat = Chat.get(recipient.id, user.ap_id)

	+ cm_ref = ChatMessageReference.for_chat_and_object(chat, object)
	+
	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: false},
	type: "pleroma:chat_mention",
	account: AccountView.render("show.json", %{user: user, for: recipient}),
	chat_message:
	- ChatMessageView.render("show.json", %{object: object, for: recipient, chat: chat}),
	+ ChatMessageReferenceView.render("show.json", %{chat_message_reference: cm_ref}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

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

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

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: 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(another_user, create_activity.id)
	{:ok, [notification]} = Notification.create_notifications(favorite_activity)
	create_activity = Activity.get_by_id(create_activity.id)

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

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

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

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: 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, follower, followed, _activity} = CommonAPI.follow(follower, followed)
	notification = Notification \|> Repo.one() \|> Repo.preload(:activity)

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: 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)
	notification = Notification \|> Repo.one() \|> Repo.preload(:activity)

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

	@tag capture_log: true
	test "Move notification" do
	old_user = insert(:user)
	new_user = insert(:user, also_known_as: [old_user.ap_id])
	follower = insert(:user)

	old_user_url = old_user.ap_id

	body =
	File.read!("test/fixtures/users_mock/localhost.json")
	\|> String.replace("{{nickname}}", old_user.nickname)
	\|> Jason.encode!()

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

	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),
	pleroma: %{is_seen: false},
	type: "move",
	account: AccountView.render("show.json", %{user: old_user, for: follower}),
	target: AccountView.render("show.json", %{user: new_user, for: follower}),
	created_at: Utils.to_masto_date(notification.inserted_at)
	}

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

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

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

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

	[notification] = Notification.for_user(user)

	assert notification

	expected = %{
	id: to_string(notification.id),
	pleroma: %{is_seen: 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)
	}

	test_notifications_rendering([notification], user, [expected])
	end
	end
	diff --git a/test/web/pleroma_api/views/chat_view_test.exs b/test/web/pleroma_api/views/chat_view_test.exs
	index 6062a0cfe..f3bd12616 100644
	--- a/test/web/pleroma_api/views/chat_view_test.exs
	+++ b/test/web/pleroma_api/views/chat_view_test.exs
	@@ -1,45 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.ChatViewTest do
	use Pleroma.DataCase

	alias Pleroma.Chat
	+ alias Pleroma.ChatMessageReference
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	- alias Pleroma.Web.PleromaAPI.ChatMessageView
	+ alias Pleroma.Web.PleromaAPI.ChatMessageReferenceView
	alias Pleroma.Web.PleromaAPI.ChatView

	import Pleroma.Factory

	test "it represents a chat" do
	user = insert(:user)
	recipient = insert(:user)

	{:ok, chat} = Chat.get_or_create(user.id, recipient.ap_id)

	represented_chat = ChatView.render("show.json", chat: chat)

	assert represented_chat == %{
	id: "#{chat.id}",
	account: AccountView.render("show.json", user: recipient),
	unread: 0,
	last_message: nil,
	updated_at: Utils.to_masto_date(chat.updated_at)
	}

	{:ok, chat_message_creation} = CommonAPI.post_chat_message(user, recipient, "hello")

	chat_message = Object.normalize(chat_message_creation, false)

	{:ok, chat} = Chat.get_or_create(user.id, recipient.ap_id)

	represented_chat = ChatView.render("show.json", chat: chat)

	+ cm_ref = ChatMessageReference.for_chat_and_object(chat, chat_message)
	+
	assert represented_chat[:last_message] ==
	- ChatMessageView.render("show.json", chat: chat, object: chat_message)
	+ ChatMessageReferenceView.render("show.json", chat_message_reference: cm_ref)
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 3:36 AM (16 h, 10 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802350
Default Alt Text: (21 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions