No OneTemporary
Actions

Authored By

Unknown

Size

18 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/side_effects.ex b/lib/pleroma/web/activity_pub/side_effects.ex
	index c8b675d54..8e64b4615 100644
	--- a/lib/pleroma/web/activity_pub/side_effects.ex
	+++ b/lib/pleroma/web/activity_pub/side_effects.ex
	@@ -1,169 +1,173 @@
	defmodule Pleroma.Web.ActivityPub.SideEffects do
	@moduledoc """
	This module looks at an inserted object and executes the side effects that it
	implies. For example, a `Like` activity will increase the like count on the
	liked object, a `Follow` activity will add the user to the follower
	collection, and so on.
	"""
	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils

	def handle(object, meta \\ [])

	# Tasks this handles:
	# - Add like to object
	# - Set up notification
	def handle(%{data: %{"type" => "Like"}} = object, meta) do
	liked_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_like_to_object(object, liked_object)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles
	# - Actually create object
	# - Rollback if we couldn't create it
	# - Set up notifications
	def handle(%{data: %{"type" => "Create"}} = activity, meta) do
	with {:ok, _object, _meta} <- handle_object_creation(meta[:object_data], meta) do
	Notification.create_notifications(activity)
	{:ok, activity, meta}
	else
	e -> Repo.rollback(e)
	end
	end

	def handle(%{data: %{"type" => "Undo", "object" => undone_object}} = object, meta) do
	with undone_object <- Activity.get_by_ap_id(undone_object),
	:ok <- handle_undoing(undone_object) do
	{:ok, object, meta}
	end
	end

	# Tasks this handles:
	# - Add reaction to object
	# - Set up notification
	def handle(%{data: %{"type" => "EmojiReact"}} = object, meta) do
	reacted_object = Object.get_by_ap_id(object.data["object"])
	Utils.add_emoji_reaction_to_object(object, reacted_object)

	Notification.create_notifications(object)

	{:ok, object, meta}
	end

	# Tasks this handles:
	# - Delete and unpins the create activity
	# - Replace object with Tombstone
	# - Set up notification
	# - Reduce the user note count
	# - Reduce the reply count
	# - Stream out the activity
	def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object, meta) do
	deleted_object =
	Object.normalize(deleted_object, false) \|\| User.get_cached_by_ap_id(deleted_object)

	result =
	case deleted_object do
	%Object{} ->
	with {:ok, deleted_object, activity} <- Object.delete(deleted_object),
	%User{} = user <- User.get_cached_by_ap_id(deleted_object.data["actor"]) do
	User.remove_pinnned_activity(user, activity)

	{:ok, user} = ActivityPub.decrease_note_count_if_public(user, deleted_object)

	if in_reply_to = deleted_object.data["inReplyTo"] do
	Object.decrease_replies_count(in_reply_to)
	end

	ActivityPub.stream_out(object)
	ActivityPub.stream_out_participations(deleted_object, user)
	:ok
	end

	%User{} ->
	with {:ok, _} <- User.delete(deleted_object) do
	:ok
	end
	end

	if result == :ok do
	Notification.create_notifications(object)
	{:ok, object, meta}
	else
	{:error, result}
	end
	end

	# Nothing to do
	def handle(object, meta) do
	{:ok, object, meta}
	end

	def handle_object_creation(%{"type" => "ChatMessage"} = object, meta) do
	with {:ok, object, meta} <- Pipeline.common_pipeline(object, meta) do
	actor = User.get_cached_by_ap_id(object.data["actor"])
	recipient = User.get_cached_by_ap_id(hd(object.data["to"]))

	[[actor, recipient], [recipient, actor]]
	\|> Enum.each(fn [user, other_user] ->
	if user.local do
	- Chat.bump_or_create(user.id, other_user.ap_id)
	+ if user.ap_id == actor.ap_id do
	+ Chat.get_or_create(user.id, other_user.ap_id)
	+ else
	+ Chat.bump_or_create(user.id, other_user.ap_id)
	+ end
	end
	end)

	{:ok, object, meta}
	end
	end

	# Nothing to do
	def handle_object_creation(object) do
	{:ok, object}
	end

	def handle_undoing(%{data: %{"type" => "Like"}} = object) do
	with %Object{} = liked_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_like_from_object(object, liked_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(%{data: %{"type" => "EmojiReact"}} = object) do
	with %Object{} = reacted_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_emoji_reaction_from_object(object, reacted_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(%{data: %{"type" => "Announce"}} = object) do
	with %Object{} = liked_object <- Object.get_by_ap_id(object.data["object"]),
	{:ok, _} <- Utils.remove_announce_from_object(object, liked_object),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(
	%{data: %{"type" => "Block", "actor" => blocker, "object" => blocked}} = object
	) do
	with %User{} = blocker <- User.get_cached_by_ap_id(blocker),
	%User{} = blocked <- User.get_cached_by_ap_id(blocked),
	{:ok, _} <- User.unblock(blocker, blocked),
	{:ok, _} <- Repo.delete(object) do
	:ok
	end
	end

	def handle_undoing(object), do: {:error, ["don't know how to handle", object]}
	end
	diff --git a/test/web/activity_pub/side_effects_test.exs b/test/web/activity_pub/side_effects_test.exs
	index 148fa4442..37d7491ca 100644
	--- a/test/web/activity_pub/side_effects_test.exs
	+++ b/test/web/activity_pub/side_effects_test.exs
	@@ -1,333 +1,354 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.SideEffectsTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Chat
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.Tests.ObanHelpers
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.SideEffects
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory
	import Mock

	describe "delete objects" do
	setup do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, op} = CommonAPI.post(other_user, %{status: "big oof"})
	{:ok, post} = CommonAPI.post(user, %{status: "hey", in_reply_to_id: op})
	{:ok, favorite} = CommonAPI.favorite(user, post.id)
	object = Object.normalize(post)
	{:ok, delete_data, _meta} = Builder.delete(user, object.data["id"])
	{:ok, delete_user_data, _meta} = Builder.delete(user, user.ap_id)
	{:ok, delete, _meta} = ActivityPub.persist(delete_data, local: true)
	{:ok, delete_user, _meta} = ActivityPub.persist(delete_user_data, local: true)

	%{
	user: user,
	delete: delete,
	post: post,
	object: object,
	delete_user: delete_user,
	op: op,
	favorite: favorite
	}
	end

	test "it handles object deletions", %{
	delete: delete,
	post: post,
	object: object,
	user: user,
	op: op,
	favorite: favorite
	} do
	with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough],
	stream_out: fn _ -> nil end,
	stream_out_participations: fn _, _ -> nil end do
	{:ok, delete, _} = SideEffects.handle(delete)
	user = User.get_cached_by_ap_id(object.data["actor"])

	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(delete))
	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out_participations(object, user))
	end

	object = Object.get_by_id(object.id)
	assert object.data["type"] == "Tombstone"
	refute Activity.get_by_id(post.id)
	refute Activity.get_by_id(favorite.id)

	user = User.get_by_id(user.id)
	assert user.note_count == 0

	object = Object.normalize(op.data["object"], false)

	assert object.data["repliesCount"] == 0
	end

	test "it handles object deletions when the object itself has been pruned", %{
	delete: delete,
	post: post,
	object: object,
	user: user,
	op: op
	} do
	with_mock Pleroma.Web.ActivityPub.ActivityPub, [:passthrough],
	stream_out: fn _ -> nil end,
	stream_out_participations: fn _, _ -> nil end do
	{:ok, delete, _} = SideEffects.handle(delete)
	user = User.get_cached_by_ap_id(object.data["actor"])

	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out(delete))
	assert called(Pleroma.Web.ActivityPub.ActivityPub.stream_out_participations(object, user))
	end

	object = Object.get_by_id(object.id)
	assert object.data["type"] == "Tombstone"
	refute Activity.get_by_id(post.id)

	user = User.get_by_id(user.id)
	assert user.note_count == 0

	object = Object.normalize(op.data["object"], false)

	assert object.data["repliesCount"] == 0
	end

	test "it handles user deletions", %{delete_user: delete, user: user} do
	{:ok, _delete, _} = SideEffects.handle(delete)
	ObanHelpers.perform_all()

	assert User.get_cached_by_ap_id(user.ap_id).deactivated
	end
	end

	describe "EmojiReact objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)

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

	{:ok, emoji_react_data, []} = Builder.emoji_react(user, post.object, "👌")
	{:ok, emoji_react, _meta} = ActivityPub.persist(emoji_react_data, local: true)

	%{emoji_react: emoji_react, user: user, poster: poster}
	end

	test "adds the reaction to the object", %{emoji_react: emoji_react, user: user} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	object = Object.get_by_ap_id(emoji_react.data["object"])

	assert object.data["reaction_count"] == 1
	assert ["👌", [user.ap_id]] in object.data["reactions"]
	end

	test "creates a notification", %{emoji_react: emoji_react, poster: poster} do
	{:ok, emoji_react, _} = SideEffects.handle(emoji_react)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: emoji_react.id)
	end
	end

	describe "Undo objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})
	{:ok, like} = CommonAPI.favorite(user, post.id)
	{:ok, reaction} = CommonAPI.react_with_emoji(post.id, user, "👍")
	{:ok, announce, _} = CommonAPI.repeat(post.id, user)
	{:ok, block} = ActivityPub.block(user, poster)
	User.block(user, poster)

	{:ok, undo_data, _meta} = Builder.undo(user, like)
	{:ok, like_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, reaction)
	{:ok, reaction_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, announce)
	{:ok, announce_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	{:ok, undo_data, _meta} = Builder.undo(user, block)
	{:ok, block_undo, _meta} = ActivityPub.persist(undo_data, local: true)

	%{
	like_undo: like_undo,
	post: post,
	like: like,
	reaction_undo: reaction_undo,
	reaction: reaction,
	announce_undo: announce_undo,
	announce: announce,
	block_undo: block_undo,
	block: block,
	poster: poster,
	user: user
	}
	end

	test "deletes the original block", %{block_undo: block_undo, block: block} do
	{:ok, _block_undo, _} = SideEffects.handle(block_undo)
	refute Activity.get_by_id(block.id)
	end

	test "unblocks the blocked user", %{block_undo: block_undo, block: block} do
	blocker = User.get_by_ap_id(block.data["actor"])
	blocked = User.get_by_ap_id(block.data["object"])

	{:ok, _block_undo, _} = SideEffects.handle(block_undo)
	refute User.blocks?(blocker, blocked)
	end

	test "an announce undo removes the announce from the object", %{
	announce_undo: announce_undo,
	post: post
	} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["announcement_count"] == 0
	assert object.data["announcements"] == []
	end

	test "deletes the original announce", %{announce_undo: announce_undo, announce: announce} do
	{:ok, _announce_undo, _} = SideEffects.handle(announce_undo)
	refute Activity.get_by_id(announce.id)
	end

	test "a reaction undo removes the reaction from the object", %{
	reaction_undo: reaction_undo,
	post: post
	} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["reaction_count"] == 0
	assert object.data["reactions"] == []
	end

	test "deletes the original reaction", %{reaction_undo: reaction_undo, reaction: reaction} do
	{:ok, _reaction_undo, _} = SideEffects.handle(reaction_undo)
	refute Activity.get_by_id(reaction.id)
	end

	test "a like undo removes the like from the object", %{like_undo: like_undo, post: post} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)

	object = Object.get_by_ap_id(post.data["object"])

	assert object.data["like_count"] == 0
	assert object.data["likes"] == []
	end

	test "deletes the original like", %{like_undo: like_undo, like: like} do
	{:ok, _like_undo, _} = SideEffects.handle(like_undo)
	refute Activity.get_by_id(like.id)
	end
	end

	describe "like objects" do
	setup do
	poster = insert(:user)
	user = insert(:user)
	{:ok, post} = CommonAPI.post(poster, %{status: "hey"})

	{:ok, like_data, _meta} = Builder.like(user, post.object)
	{:ok, like, _meta} = ActivityPub.persist(like_data, local: true)

	%{like: like, user: user, poster: poster}
	end

	test "add the like to the original object", %{like: like, user: user} do
	{:ok, like, _} = SideEffects.handle(like)
	object = Object.get_by_ap_id(like.data["object"])
	assert object.data["like_count"] == 1
	assert user.ap_id in object.data["likes"]
	end

	test "creates a notification", %{like: like, poster: poster} do
	{:ok, like, _} = SideEffects.handle(like)
	assert Repo.get_by(Notification, user_id: poster.id, activity_id: like.id)
	end
	end

	describe "creation of ChatMessages" do
	test "notifies the recipient" do
	author = insert(:user, local: false)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	assert Repo.get_by(Notification, user_id: recipient.id, activity_id: create_activity.id)
	end

	+ test "it creates a Chat for the local users and bumps the unread count, except for the author" do
	+ author = insert(:user, local: true)
	+ recipient = insert(:user, local: true)
	+
	+ {:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")
	+
	+ {:ok, create_activity_data, _meta} =
	+ Builder.create(author, chat_message_data["id"], [recipient.ap_id])
	+
	+ {:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)
	+
	+ {:ok, _create_activity, _meta} =
	+ SideEffects.handle(create_activity, local: false, object_data: chat_message_data)
	+
	+ chat = Chat.get(author.id, recipient.ap_id)
	+ assert chat.unread == 0
	+
	+ chat = Chat.get(recipient.id, author.ap_id)
	+ assert chat.unread == 1
	+ end
	+
	test "it creates a Chat for the local users and bumps the unread count" do
	author = insert(:user, local: false)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# An object is created
	assert Object.get_by_ap_id(chat_message_data["id"])

	# The remote user won't get a chat
	chat = Chat.get(author.id, recipient.ap_id)
	refute chat

	# The local user will get a chat
	chat = Chat.get(recipient.id, author.ap_id)
	assert chat

	author = insert(:user, local: true)
	recipient = insert(:user, local: true)

	{:ok, chat_message_data, _meta} = Builder.chat_message(author, recipient.ap_id, "hey")

	{:ok, create_activity_data, _meta} =
	Builder.create(author, chat_message_data["id"], [recipient.ap_id])

	{:ok, create_activity, _meta} = ActivityPub.persist(create_activity_data, local: false)

	{:ok, _create_activity, _meta} =
	SideEffects.handle(create_activity, local: false, object_data: chat_message_data)

	# Both users are local and get the chat
	chat = Chat.get(author.id, recipient.ap_id)
	assert chat

	chat = Chat.get(recipient.id, author.ap_id)
	assert chat
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 11:27 PM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798821
Default Alt Text: (18 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions