No OneTemporary
Actions

Size

30 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/builder.ex b/lib/pleroma/web/activity_pub/builder.ex
	index 7576ed278..7f9c071b3 100644
	--- a/lib/pleroma/web/activity_pub/builder.ex
	+++ b/lib/pleroma/web/activity_pub/builder.ex
	@@ -1,69 +1,69 @@
	defmodule Pleroma.Web.ActivityPub.Builder do
	@moduledoc """
	This module builds the objects. Meant to be used for creating local objects.

	This module encodes our addressing policies and general shape of our objects.
	"""

	alias Pleroma.Emoji
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	- def create(actor, object_id, recipients) do
	+ def create(actor, object, recipients) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"to" => recipients,
	- "object" => object_id,
	+ "object" => object,
	"type" => "Create",
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}, []}
	end

	def chat_message(actor, recipient, content) do
	{:ok,
	%{
	"id" => Utils.generate_object_id(),
	"actor" => actor.ap_id,
	"type" => "ChatMessage",
	"to" => [recipient],
	"content" => content,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"emoji" => Emoji.Formatter.get_emoji_map(content)
	}, []}
	end

	@spec like(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def like(actor, object) do
	object_actor = User.get_cached_by_ap_id(object.data["actor"])

	# Address the actor of the object, and our actor's follower collection if the post is public.
	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	# CC everyone who's been addressed in the object, except ourself and the object actor's
	# follower collection
	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => "Like",
	"object" => object.data["id"],
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}, []}
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index a4da9242a..bada3509d 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,67 +1,75 @@
	# 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.ObjectValidator do
	@moduledoc """
	This module is responsible for validating an object (which can be an activity)
	and checking if it is both well formed and also compatible with our view of
	the system.
	"""

	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator

	@spec validate(map(), keyword()) :: {:ok, map(), keyword()} \| {:error, any()}
	def validate(object, meta)

	def validate(%{"type" => "Like"} = object, meta) do
	with {:ok, object} <-
	object
	\|> LikeValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "ChatMessage"} = object, meta) do
	with {:ok, object} <-
	object
	\|> ChatMessageValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	- def validate(%{"type" => "Create"} = object, meta) do
	- with {:ok, object} <-
	- object
	+ def validate(%{"type" => "Create", "object" => object} = create_activity, meta) do
	+ with {:ok, object_data} <- cast_and_apply(object),
	+ meta = Keyword.put(meta, :object_data, object_data \|> stringify_keys),
	+ {:ok, create_activity} <-
	+ create_activity
	\|> CreateChatMessageValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	- object = stringify_keys(object)
	- {:ok, object, meta}
	+ create_activity = stringify_keys(create_activity)
	+ {:ok, create_activity, meta}
	end
	end

	+ def cast_and_apply(%{"type" => "ChatMessage"} = object) do
	+ ChatMessageValidator.cast_and_apply(object)
	+ end
	+
	+ def cast_and_apply(o), do: {:error, {:validator_not_set, o}}
	+
	def stringify_keys(%{__struct__: _} = object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) do
	object
	\|> Map.new(fn {key, val} -> {to_string(key), val} end)
	end

	def fetch_actor_and_object(object) do
	User.get_or_fetch_by_ap_id(object["actor"])
	Object.normalize(object["object"])
	:ok
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier/chat_message_handling.ex b/lib/pleroma/web/activity_pub/transmogrifier/chat_message_handling.ex
	index 043d847d1..d9c36e313 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier/chat_message_handling.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier/chat_message_handling.ex
	@@ -1,45 +1,26 @@
	# 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.Transmogrifier.ChatMessageHandling do
	alias Pleroma.Repo
	- alias Pleroma.Web.ActivityPub.ObjectValidator
	- alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	- alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.Pipeline

	def handle_incoming(
	%{"type" => "Create", "object" => %{"type" => "ChatMessage"}} = data,
	_options
	) do
	# Create has to be run inside a transaction because the object is created as a side effect.
	# If this does not work, we need to roll back creating the activity.
	- case Repo.transaction(fn -> do_handle_incoming(data) end) do
	- {:ok, value} ->
	- value
	+ case Repo.transaction(fn -> Pipeline.common_pipeline(data, local: false) end) do
	+ {:ok, {:ok, activity, _}} ->
	+ {:ok, activity}

	- {:error, e} ->
	- {:error, e}
	- end
	- end
	+ {:ok, e} ->
	+ e

	- def do_handle_incoming(
	- %{"type" => "Create", "object" => %{"type" => "ChatMessage"} = object_data} = data
	- ) do
	- with {_, {:ok, cast_data_sym}} <-
	- {:casting_data, data \|> CreateChatMessageValidator.cast_and_apply()},
	- cast_data = ObjectValidator.stringify_keys(cast_data_sym),
	- {_, {:ok, object_cast_data_sym}} <-
	- {:casting_object_data, object_data \|> ChatMessageValidator.cast_and_apply()},
	- object_cast_data = ObjectValidator.stringify_keys(object_cast_data_sym),
	- {_, {:ok, activity, _meta}} <-
	- {:common_pipeline,
	- Pipeline.common_pipeline(cast_data, local: false, object_data: object_cast_data)} do
	- {:ok, activity}
	- else
	- e ->
	+ {:error, e} ->
	{:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
	index c39d1cee6..ef86ec1e4 100644
	--- a/lib/pleroma/web/common_api/common_api.ex
	+++ b/lib/pleroma/web/common_api/common_api.ex
	@@ -1,501 +1,500 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI do
	alias Pleroma.Activity
	alias Pleroma.ActivityExpiration
	alias Pleroma.Conversation.Participation
	alias Pleroma.FollowingRelationship
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	import Pleroma.Web.Gettext
	import Pleroma.Web.CommonAPI.Utils

	require Pleroma.Constants
	require Logger

	def post_chat_message(%User{} = user, %User{} = recipient, content) do
	transaction =
	Repo.transaction(fn ->
	with {_, true} <-
	{:content_length,
	String.length(content) <= Pleroma.Config.get([:instance, :chat_limit])},
	{_, {:ok, chat_message_data, _meta}} <-
	{:build_object,
	Builder.chat_message(
	user,
	recipient.ap_id,
	content \|> Formatter.html_escape("text/plain")
	)},
	{_, {:ok, create_activity_data, _meta}} <-
	{:build_create_activity,
	- Builder.create(user, chat_message_data["id"], [recipient.ap_id])},
	+ Builder.create(user, chat_message_data, [recipient.ap_id])},
	{_, {:ok, %Activity{} = activity, _meta}} <-
	{:common_pipeline,
	Pipeline.common_pipeline(create_activity_data,
	- local: true,
	- object_data: chat_message_data
	+ local: true
	)} do
	{:ok, activity}
	else
	{:content_length, false} -> {:error, :content_too_long}
	e -> e
	end
	end)

	case transaction do
	{:ok, value} -> value
	error -> error
	end
	end

	def follow(follower, followed) do
	timeout = Pleroma.Config.get([:activitypub, :follow_handshake_timeout])

	with {:ok, follower} <- User.maybe_direct_follow(follower, followed),
	{:ok, activity} <- ActivityPub.follow(follower, followed),
	{:ok, follower, followed} <- User.wait_and_refresh(timeout, follower, followed) do
	{:ok, follower, followed, activity}
	end
	end

	def unfollow(follower, unfollowed) do
	with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
	{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed),
	{:ok, _subscription} <- User.unsubscribe(follower, unfollowed) do
	{:ok, follower}
	end
	end

	def accept_follow_request(follower, followed) do
	with {:ok, follower} <- User.follow(follower, followed),
	%Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept),
	{:ok, _activity} <-
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Accept"
	}) do
	{:ok, follower}
	end
	end

	def reject_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
	{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
	{:ok, _activity} <-
	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Reject"
	}) do
	{:ok, follower}
	end
	end

	def delete(activity_id, user) do
	with {_, %Activity{data: %{"object" => _}} = activity} <-
	{:find_activity, Activity.get_by_id_with_object(activity_id)},
	%Object{} = object <- Object.normalize(activity),
	true <- User.superuser?(user) \|\| user.ap_id == object.data["actor"],
	{:ok, _} <- unpin(activity_id, user),
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not delete")}
	end
	end

	def repeat(id, user, params \\ %{}) do
	with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(id)},
	object <- Object.normalize(activity),
	announce_activity <- Utils.get_existing_announce(user.ap_id, object),
	public <- public_announce?(object, params) do
	if announce_activity do
	{:ok, announce_activity, object}
	else
	ActivityPub.announce(user, object, nil, true, public)
	end
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not repeat")}
	end
	end

	def unrepeat(id, user) do
	with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(id)} do
	object = Object.normalize(activity)
	ActivityPub.unannounce(user, object)
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unrepeat")}
	end
	end

	@spec favorite(User.t(), binary()) :: {:ok, Activity.t() \| :already_liked} \| {:error, any()}
	def favorite(%User{} = user, id) do
	case favorite_helper(user, id) do
	{:ok, _} = res ->
	res

	{:error, :not_found} = res ->
	res

	{:error, e} ->
	Logger.error("Could not favorite #{id}. Error: #{inspect(e, pretty: true)}")
	{:error, dgettext("errors", "Could not favorite")}
	end
	end

	def favorite_helper(user, id) do
	with {_, %Activity{object: object}} <- {:find_object, Activity.get_by_id_with_object(id)},
	{_, {:ok, like_object, meta}} <- {:build_object, Builder.like(user, object)},
	{_, {:ok, %Activity{} = activity, _meta}} <-
	{:common_pipeline,
	Pipeline.common_pipeline(like_object, Keyword.put(meta, :local, true))} do
	{:ok, activity}
	else
	{:find_object, _} ->
	{:error, :not_found}

	{:common_pipeline,
	{
	:error,
	{
	:validate_object,
	{
	:error,
	changeset
	}
	}
	}} = e ->
	if {:object, {"already liked by this actor", []}} in changeset.errors do
	{:ok, :already_liked}
	else
	{:error, e}
	end

	e ->
	{:error, e}
	end
	end

	def unfavorite(id, user) do
	with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
	{:find_activity, Activity.get_by_id(id)} do
	object = Object.normalize(activity)
	ActivityPub.unlike(user, object)
	else
	{:find_activity, _} -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not unfavorite")}
	end
	end

	def react_with_emoji(id, user, emoji) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	object <- Object.normalize(activity) do
	ActivityPub.react_with_emoji(user, object, emoji)
	else
	_ ->
	{:error, dgettext("errors", "Could not add reaction emoji")}
	end
	end

	def unreact_with_emoji(id, user, emoji) do
	with %Activity{} = reaction_activity <- Utils.get_latest_reaction(id, user, emoji) do
	ActivityPub.unreact_with_emoji(user, reaction_activity.data["id"])
	else
	_ ->
	{:error, dgettext("errors", "Could not remove reaction emoji")}
	end
	end

	def vote(user, %{data: %{"type" => "Question"}} = object, choices) do
	with :ok <- validate_not_author(object, user),
	:ok <- validate_existing_votes(user, object),
	{:ok, options, choices} <- normalize_and_validate_choices(choices, object) do
	answer_activities =
	Enum.map(choices, fn index ->
	answer_data = make_answer_data(user, object, Enum.at(options, index)["name"])

	{:ok, activity} =
	ActivityPub.create(%{
	to: answer_data["to"],
	actor: user,
	context: object.data["context"],
	object: answer_data,
	additional: %{"cc" => answer_data["cc"]}
	})

	activity
	end)

	object = Object.get_cached_by_ap_id(object.data["id"])
	{:ok, answer_activities, object}
	end
	end

	defp validate_not_author(%{data: %{"actor" => ap_id}}, %{ap_id: ap_id}),
	do: {:error, dgettext("errors", "Poll's author can't vote")}

	defp validate_not_author(_, _), do: :ok

	defp validate_existing_votes(%{ap_id: ap_id}, object) do
	if Utils.get_existing_votes(ap_id, object) == [] do
	:ok
	else
	{:error, dgettext("errors", "Already voted")}
	end
	end

	defp get_options_and_max_count(%{data: %{"anyOf" => any_of}}), do: {any_of, Enum.count(any_of)}
	defp get_options_and_max_count(%{data: %{"oneOf" => one_of}}), do: {one_of, 1}

	defp normalize_and_validate_choices(choices, object) do
	choices = Enum.map(choices, fn i -> if is_binary(i), do: String.to_integer(i), else: i end)
	{options, max_count} = get_options_and_max_count(object)
	count = Enum.count(options)

	with {_, true} <- {:valid_choice, Enum.all?(choices, &(&1 < count))},
	{_, true} <- {:count_check, Enum.count(choices) <= max_count} do
	{:ok, options, choices}
	else
	{:valid_choice, _} -> {:error, dgettext("errors", "Invalid indices")}
	{:count_check, _} -> {:error, dgettext("errors", "Too many choices")}
	end
	end

	def public_announce?(_, %{"visibility" => visibility})
	when visibility in ~w{public unlisted private direct},
	do: visibility in ~w(public unlisted)

	def public_announce?(object, _) do
	Visibility.is_public?(object)
	end

	def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}

	def get_visibility(%{"visibility" => visibility}, in_reply_to, _)
	when visibility in ~w{public unlisted private direct},
	do: {visibility, get_replied_to_visibility(in_reply_to)}

	def get_visibility(%{"visibility" => "list:" <> list_id}, in_reply_to, _) do
	visibility = {:list, String.to_integer(list_id)}
	{visibility, get_replied_to_visibility(in_reply_to)}
	end

	def get_visibility(_, in_reply_to, _) when not is_nil(in_reply_to) do
	visibility = get_replied_to_visibility(in_reply_to)
	{visibility, visibility}
	end

	def get_visibility(_, in_reply_to, _), do: {"public", get_replied_to_visibility(in_reply_to)}

	def get_replied_to_visibility(nil), do: nil

	def get_replied_to_visibility(activity) do
	with %Object{} = object <- Object.normalize(activity) do
	Visibility.get_visibility(object)
	end
	end

	def check_expiry_date({:ok, nil} = res), do: res

	def check_expiry_date({:ok, in_seconds}) do
	expiry = NaiveDateTime.utc_now() \|> NaiveDateTime.add(in_seconds)

	if ActivityExpiration.expires_late_enough?(expiry) do
	{:ok, expiry}
	else
	{:error, "Expiry date is too soon"}
	end
	end

	def check_expiry_date(expiry_str) do
	Ecto.Type.cast(:integer, expiry_str)
	\|> check_expiry_date()
	end

	def listen(user, %{"title" => _} = data) do
	with visibility <- data["visibility"] \|\| "public",
	{to, cc} <- get_to_and_cc(user, [], nil, visibility, nil),
	listen_data <-
	Map.take(data, ["album", "artist", "title", "length"])
	\|> Map.put("type", "Audio")
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)
	\|> Map.put("actor", user.ap_id),
	{:ok, activity} <-
	ActivityPub.listen(%{
	actor: user,
	to: to,
	object: listen_data,
	context: Utils.generate_context_id(),
	additional: %{"cc" => cc}
	}) do
	{:ok, activity}
	end
	end

	def post(user, %{"status" => _} = data) do
	with {:ok, draft} <- Pleroma.Web.CommonAPI.ActivityDraft.create(user, data) do
	draft.changes
	\|> ActivityPub.create(draft.preview?)
	\|> maybe_create_activity_expiration(draft.expires_at)
	end
	end

	defp maybe_create_activity_expiration({:ok, activity}, %NaiveDateTime{} = expires_at) do
	with {:ok, _} <- ActivityExpiration.create(activity, expires_at) do
	{:ok, activity}
	end
	end

	defp maybe_create_activity_expiration(result, _), do: result

	def pin(id, %{ap_id: user_ap_id} = user) do
	with %Activity{
	actor: ^user_ap_id,
	data: %{"type" => "Create"},
	object: %Object{data: %{"type" => object_type}}
	} = activity <- Activity.get_by_id_with_object(id),
	true <- object_type in ["Note", "Article", "Question"],
	true <- Visibility.is_public?(activity),
	{:ok, _user} <- User.add_pinnned_activity(user, activity) do
	{:ok, activity}
	else
	{:error, %{errors: [pinned_activities: {err, _}]}} -> {:error, err}
	_ -> {:error, dgettext("errors", "Could not pin")}
	end
	end

	def unpin(id, user) do
	with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id(id),
	{:ok, _user} <- User.remove_pinnned_activity(user, activity) do
	{:ok, activity}
	else
	{:error, %{errors: [pinned_activities: {err, _}]}} -> {:error, err}
	_ -> {:error, dgettext("errors", "Could not unpin")}
	end
	end

	def add_mute(user, activity) do
	with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]) do
	{:ok, activity}
	else
	{:error, _} -> {:error, dgettext("errors", "conversation is already muted")}
	end
	end

	def remove_mute(user, activity) do
	ThreadMute.remove_mute(user.id, activity.data["context"])
	{:ok, activity}
	end

	def thread_muted?(%{id: nil} = _user, _activity), do: false

	def thread_muted?(user, activity) do
	ThreadMute.exists?(user.id, activity.data["context"])
	end

	def report(user, %{"account_id" => account_id} = data) do
	with {:ok, account} <- get_reported_account(account_id),
	{:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]),
	{:ok, statuses} <- get_report_statuses(account, data) do
	ActivityPub.flag(%{
	context: Utils.generate_context_id(),
	actor: user,
	account: account,
	statuses: statuses,
	content: content_html,
	forward: data["forward"] \|\| false
	})
	end
	end

	def report(_user, _params), do: {:error, dgettext("errors", "Valid `account_id` required")}

	defp get_reported_account(account_id) do
	case User.get_cached_by_id(account_id) do
	%User{} = account -> {:ok, account}
	_ -> {:error, dgettext("errors", "Account not found")}
	end
	end

	def update_report_state(activity_ids, state) when is_list(activity_ids) do
	case Utils.update_report_state(activity_ids, state) do
	:ok -> {:ok, activity_ids}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_report_state(activity_id, state) do
	with %Activity{} = activity <- Activity.get_by_id(activity_id) do
	Utils.update_report_state(activity, state)
	else
	nil -> {:error, :not_found}
	_ -> {:error, dgettext("errors", "Could not update state")}
	end
	end

	def update_activity_scope(activity_id, opts \\ %{}) do
	with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
	{:ok, activity} <- toggle_sensitive(activity, opts) do
	set_visibility(activity, opts)
	else
	nil -> {:error, :not_found}
	{:error, reason} -> {:error, reason}
	end
	end

	defp toggle_sensitive(activity, %{"sensitive" => sensitive}) when sensitive in ~w(true false) do
	toggle_sensitive(activity, %{"sensitive" => String.to_existing_atom(sensitive)})
	end

	defp toggle_sensitive(%Activity{object: object} = activity, %{"sensitive" => sensitive})
	when is_boolean(sensitive) do
	new_data = Map.put(object.data, "sensitive", sensitive)

	{:ok, object} =
	object
	\|> Object.change(%{data: new_data})
	\|> Object.update_and_set_cache()

	{:ok, Map.put(activity, :object, object)}
	end

	defp toggle_sensitive(activity, _), do: {:ok, activity}

	defp set_visibility(activity, %{"visibility" => visibility}) do
	Utils.update_activity_visibility(activity, visibility)
	end

	defp set_visibility(activity, _), do: {:ok, activity}

	def hide_reblogs(%User{} = user, %User{} = target) do
	UserRelationship.create_reblog_mute(user, target)
	end

	def show_reblogs(%User{} = user, %User{} = target) do
	UserRelationship.delete_reblog_mute(user, target)
	end
	end
	diff --git a/test/web/activity_pub/object_validator_test.exs b/test/web/activity_pub/object_validator_test.exs
	index baa4b2585..41f67964a 100644
	--- a/test/web/activity_pub/object_validator_test.exs
	+++ b/test/web/activity_pub/object_validator_test.exs
	@@ -1,170 +1,170 @@
	defmodule Pleroma.Web.ActivityPub.ObjectValidatorTest do
	use Pleroma.DataCase

	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	describe "chat message create activities" do
	test "it is invalid if the object already exists" do
	user = insert(:user)
	recipient = insert(:user)
	{:ok, activity} = CommonAPI.post_chat_message(user, recipient, "hey")
	object = Object.normalize(activity, false)

	- {:ok, create_data, _} = Builder.create(user, object.data["id"], [recipient.ap_id])
	+ {:ok, create_data, _} = Builder.create(user, object.data, [recipient.ap_id])

	{:error, cng} = ObjectValidator.validate(create_data, [])

	assert {:object, {"The object to create already exists", []}} in cng.errors
	end
	end

	describe "chat messages" do
	setup do
	clear_config([:instance, :remote_limit])
	user = insert(:user)
	recipient = insert(:user, local: false)

	{:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey :firefox:")

	%{user: user, recipient: recipient, valid_chat_message: valid_chat_message}
	end

	test "validates for a basic object we build", %{valid_chat_message: valid_chat_message} do
	assert {:ok, object, _meta} = ObjectValidator.validate(valid_chat_message, [])

	assert object == valid_chat_message
	end

	test "does not validate if the message is longer than the remote_limit", %{
	valid_chat_message: valid_chat_message
	} do
	Pleroma.Config.put([:instance, :remote_limit], 2)
	refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
	end

	test "does not validate if the recipient is blocking the actor", %{
	valid_chat_message: valid_chat_message,
	user: user,
	recipient: recipient
	} do
	Pleroma.User.block(recipient, user)
	refute match?({:ok, _object, _meta}, ObjectValidator.validate(valid_chat_message, []))
	end

	test "does not validate if the actor or the recipient is not in our system", %{
	valid_chat_message: valid_chat_message
	} do
	chat_message =
	valid_chat_message
	\|> Map.put("actor", "https://raymoo.com/raymoo")

	{:error, _} = ObjectValidator.validate(chat_message, [])

	chat_message =
	valid_chat_message
	\|> Map.put("to", ["https://raymoo.com/raymoo"])

	{:error, _} = ObjectValidator.validate(chat_message, [])
	end

	test "does not validate for a message with multiple recipients", %{
	valid_chat_message: valid_chat_message,
	user: user,
	recipient: recipient
	} do
	chat_message =
	valid_chat_message
	\|> Map.put("to", [user.ap_id, recipient.ap_id])

	assert {:error, _} = ObjectValidator.validate(chat_message, [])
	end

	test "does not validate if it doesn't concern local users" do
	user = insert(:user, local: false)
	recipient = insert(:user, local: false)

	{:ok, valid_chat_message, _} = Builder.chat_message(user, recipient.ap_id, "hey")
	assert {:error, _} = ObjectValidator.validate(valid_chat_message, [])
	end
	end

	describe "likes" do
	setup do
	user = insert(:user)
	{:ok, post_activity} = CommonAPI.post(user, %{"status" => "uguu"})

	valid_like = %{
	"to" => [user.ap_id],
	"cc" => [],
	"type" => "Like",
	"id" => Utils.generate_activity_id(),
	"object" => post_activity.data["object"],
	"actor" => user.ap_id,
	"context" => "a context"
	}

	%{valid_like: valid_like, user: user, post_activity: post_activity}
	end

	test "returns ok when called in the ObjectValidator", %{valid_like: valid_like} do
	{:ok, object, _meta} = ObjectValidator.validate(valid_like, [])

	assert "id" in Map.keys(object)
	end

	test "is valid for a valid object", %{valid_like: valid_like} do
	assert LikeValidator.cast_and_validate(valid_like).valid?
	end

	test "it errors when the actor is missing or not known", %{valid_like: valid_like} do
	without_actor = Map.delete(valid_like, "actor")

	refute LikeValidator.cast_and_validate(without_actor).valid?

	with_invalid_actor = Map.put(valid_like, "actor", "invalidactor")

	refute LikeValidator.cast_and_validate(with_invalid_actor).valid?
	end

	test "it errors when the object is missing or not known", %{valid_like: valid_like} do
	without_object = Map.delete(valid_like, "object")

	refute LikeValidator.cast_and_validate(without_object).valid?

	with_invalid_object = Map.put(valid_like, "object", "invalidobject")

	refute LikeValidator.cast_and_validate(with_invalid_object).valid?
	end

	test "it errors when the actor has already like the object", %{
	valid_like: valid_like,
	user: user,
	post_activity: post_activity
	} do
	_like = CommonAPI.favorite(user, post_activity.id)

	refute LikeValidator.cast_and_validate(valid_like).valid?
	end

	test "it works when actor or object are wrapped in maps", %{valid_like: valid_like} do
	wrapped_like =
	valid_like
	\|> Map.put("actor", %{"id" => valid_like["actor"]})
	\|> Map.put("object", %{"id" => valid_like["object"]})

	validated = LikeValidator.cast_and_validate(wrapped_like)

	assert validated.valid?

	assert {:actor, valid_like["actor"]} in validated.changes
	assert {:object, valid_like["object"]} in validated.changes
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 9, 3:45 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1724167
Default Alt Text: (30 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions