No OneTemporary
Actions

Authored By

Unknown

Size

42 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index 1d083c159..a489adbca 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,984 +1,966 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Ecto.Changeset
	alias Ecto.UUID
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.EctoType.ActivityPub.ObjectValidators.ObjectID
	alias Pleroma.Maps
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query
	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

	require Logger
	require Pleroma.Constants

	@supported_object_types [
	"Article",
	"Note",
	"Event",
	"Video",
	"Page",
	"Question",
	"Answer",
	"Audio",
	"Image"
	]
	@strip_status_report_states ~w(closed resolved)
	@supported_report_states ~w(open closed resolved)
	@valid_visibilities ~w(public unlisted private direct)

	def as_local_public, do: Endpoint.url() <> "/#Public"

	# Some implementations send the actor URI as the actor field, others send the entire actor object,
	# so figure out what the actor's URI is based on what we have.
	def get_ap_id(%{"id" => id} = _), do: id
	def get_ap_id(id), do: id

	def normalize_params(params) do
	Map.put(params, "actor", get_ap_id(params["actor"]))
	end

	@spec determine_explicit_mentions(map()) :: [any]
	def determine_explicit_mentions(%{"tag" => tag}) when is_list(tag) do
	Enum.flat_map(tag, fn
	%{"type" => "Mention", "href" => href} -> [href]
	_ -> []
	end)
	end

	def determine_explicit_mentions(%{"tag" => tag} = object) when is_map(tag) do
	object
	\|> Map.put("tag", [tag])
	\|> determine_explicit_mentions()
	end

	def determine_explicit_mentions(_), do: []

	@spec label_in_collection?(any(), any()) :: boolean()
	defp label_in_collection?(ap_id, coll) when is_binary(coll), do: ap_id == coll
	defp label_in_collection?(ap_id, coll) when is_list(coll), do: ap_id in coll
	defp label_in_collection?(_, _), do: false

	@spec label_in_message?(String.t(), map()) :: boolean()
	def label_in_message?(label, params),
	do:
	[params["to"], params["cc"], params["bto"], params["bcc"]]
	\|> Enum.any?(&label_in_collection?(label, &1))

	@spec unaddressed_message?(map()) :: boolean()
	def unaddressed_message?(params),
	do:
	[params["to"], params["cc"], params["bto"], params["bcc"]]
	\|> Enum.all?(fn
	nil -> true
	[] -> true
	_ -> false
	end)

	@spec recipient_in_message(User.t(), User.t(), map()) :: boolean()
	def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params),
	do:
	label_in_message?(ap_id, params) \|\| unaddressed_message?(params) \|\|
	User.following?(recipient, actor)

	defp extract_list(target) when is_binary(target), do: [target]
	defp extract_list(lst) when is_list(lst), do: lst
	defp extract_list(_), do: []

	def maybe_splice_recipient(ap_id, params) do
	need_splice? =
	!label_in_collection?(ap_id, params["to"]) &&
	!label_in_collection?(ap_id, params["cc"])

	if need_splice? do
	cc = [ap_id \| extract_list(params["cc"])]

	params
	\|> Map.put("cc", cc)
	\|> Maps.safe_put_in(["object", "cc"], cc)
	else
	params
	end
	end

	def make_json_ld_header(data \\ %{}) do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"#{Endpoint.url()}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => get_language(data),
	"htmlMfm" => "https://w3id.org/fep/c16b#htmlMfm"
	}
	]
	}
	end

	defp get_language(%{"language" => language}) when not_empty_string(language) do
	language
	end

	defp get_language(_), do: "und"

	def make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601()
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Helpers.o_status_url(Endpoint, :object, UUID.generate())
	end

	def generate_id(type) do
	"#{Endpoint.url()}/#{type}/#{UUID.generate()}"
	end

	def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
	fake_create_activity = %{
	"to" => object["to"],
	"cc" => object["cc"],
	"type" => "Create",
	"object" => object
	}

	get_notified_from_object(fake_create_activity)
	end

	def get_notified_from_object(object) do
	Notification.get_notified_from_activity(%Activity{data: object}, false)
	end

	def maybe_create_context(context), do: context \|\| generate_id("contexts")

	- @doc """
	- Enqueues an activity for federation if it's local
	- """
	- @spec maybe_federate(any()) :: :ok
	- def maybe_federate(%Activity{local: true, data: %{"type" => type}} = activity) do
	- outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
	-
	- with true <- Config.get!([:instance, :federating]),
	- true <- type != "Block" \|\| outgoing_blocks,
	- false <- Visibility.local_public?(activity) do
	- Pleroma.Web.Federator.publish(activity)
	- end
	-
	- :ok
	- end
	-
	- def maybe_federate(_), do: :ok
	-
	@doc """
	Adds an id and a published data if they aren't there,
	also adds it to an included object
	"""
	@spec lazy_put_activity_defaults(map(), boolean) :: map()
	def lazy_put_activity_defaults(map, fake? \\ false)

	def lazy_put_activity_defaults(map, true) do
	map
	\|> Map.put_new("id", "pleroma:fakeid")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", "pleroma:fakecontext")
	\|> lazy_put_object_defaults(true)
	end

	def lazy_put_activity_defaults(map, _fake?) do
	context = maybe_create_context(map["context"])

	map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", context)
	\|> lazy_put_object_defaults(false)
	end

	# Adds an id and published date if they aren't there.
	#
	@spec lazy_put_object_defaults(map(), boolean()) :: map()
	defp lazy_put_object_defaults(%{"object" => map} = activity, true)
	when is_map(map) do
	object =
	map
	\|> Map.put_new("id", "pleroma:fake_object_id")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("fake", true)

	%{activity \| "object" => object}
	end

	defp lazy_put_object_defaults(%{"object" => map} = activity, _)
	when is_map(map) do
	object =
	map
	\|> Map.put_new_lazy("id", &generate_object_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])

	%{activity \| "object" => object}
	end

	defp lazy_put_object_defaults(activity, _), do: activity

	@doc """
	Inserts a full object if it is contained in an activity.
	"""
	def insert_full_object(%{"object" => %{"type" => type} = object_data} = map)
	when type in @supported_object_types do
	with {:ok, object} <- Object.create(object_data) do
	map = Map.put(map, "object", object.data["id"])

	{:ok, map, object}
	end
	end

	def insert_full_object(map), do: {:ok, map, nil}

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	@spec get_existing_like(String.t(), map()) :: Activity.t() \| nil
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_object_id(id)
	\|> Activity.Queries.by_type("Like")
	\|> limit(1)
	\|> Repo.one()
	end

	@doc """
	Returns like activities targeting an object
	"""
	def get_object_likes(%{data: %{"id" => id}}) do
	id
	\|> Activity.Queries.by_object_id()
	\|> Activity.Queries.by_type("Like")
	\|> Repo.all()
	end

	@spec make_like_data(User.t(), map(), String.t()) :: map()
	def make_like_data(
	%User{ap_id: ap_id} = actor,
	%{data: %{"actor" => object_actor_id, "id" => id}} = object,
	activity_id
	) do
	object_actor = User.get_cached_by_ap_id(object_actor_id)

	to =
	if Visibility.public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	%{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_emoji_reaction_data(user, object, emoji, activity_id) do
	make_like_data(user, object, activity_id)
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("content", emoji)
	end

	@spec update_element_in_object(String.t(), list(any), Object.t(), integer() \| nil) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def update_element_in_object(property, element, object, count \\ nil) do
	length =
	count \|\|
	length(element)

	data =
	Map.merge(
	object.data,
	%{"#{property}_count" => length, "#{property}s" => element}
	)

	object
	\|> Changeset.change(data: data)
	\|> Object.update_and_set_cache()
	end

	@spec add_emoji_reaction_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}

	def add_emoji_reaction_to_object(
	%Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
	object
	) do
	reactions = get_cached_emoji_reactions(object)
	emoji = Pleroma.Emoji.maybe_strip_name(emoji)
	url = maybe_emoji_url(emoji, activity)

	new_reactions =
	case Enum.find_index(reactions, fn [candidate, _, candidate_url] ->
	if is_nil(candidate_url) do
	emoji == candidate
	else
	url == candidate_url
	end
	end) do
	nil ->
	reactions ++ [[emoji, [actor], url]]

	index ->
	List.update_at(
	reactions,
	index,
	fn [emoji, users, url] -> [emoji, Enum.uniq([actor \| users]), url] end
	)
	end

	count = emoji_count(new_reactions)

	update_element_in_object("reaction", new_reactions, object, count)
	end

	defp maybe_emoji_url(
	name,
	%Activity{
	data: %{
	"tag" => [
	%{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}
	]
	}
	}
	),
	do: url

	defp maybe_emoji_url(_, _), do: nil

	def emoji_count(reactions_list) do
	Enum.reduce(reactions_list, 0, fn [_, users, _], acc -> acc + length(users) end)
	end

	def remove_emoji_reaction_from_object(
	%Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
	object
	) do
	emoji = Pleroma.Emoji.maybe_strip_name(emoji)
	reactions = get_cached_emoji_reactions(object)
	url = maybe_emoji_url(emoji, activity)

	new_reactions =
	case Enum.find_index(reactions, fn [candidate, _, candidate_url] ->
	if is_nil(candidate_url) do
	emoji == candidate
	else
	url == candidate_url
	end
	end) do
	nil ->
	reactions

	index ->
	List.update_at(
	reactions,
	index,
	fn [emoji, users, url] -> [emoji, List.delete(users, actor), url] end
	)
	\|> Enum.reject(fn [_, users, _] -> Enum.empty?(users) end)
	end

	count = emoji_count(new_reactions)
	update_element_in_object("reaction", new_reactions, object, count)
	end

	def get_cached_emoji_reactions(object) do
	Object.get_emoji_reactions(object)
	end

	@spec add_like_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	[actor \| fetch_likes(object)]
	\|> Enum.uniq()
	\|> update_likes_in_object(object)
	end

	@spec remove_like_from_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	object
	\|> fetch_likes()
	\|> List.delete(actor)
	\|> update_likes_in_object(object)
	end

	defp update_likes_in_object(likes, object) do
	update_element_in_object("like", likes, object)
	end

	defp fetch_likes(object) do
	if is_list(object.data["likes"]) do
	object.data["likes"]
	else
	[]
	end
	end

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	@spec update_follow_state_for_all(Activity.t(), String.t()) :: {:ok, Activity \| nil}
	def update_follow_state_for_all(
	%Activity{data: %{"actor" => actor, "object" => object}} = activity,
	state
	) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> Activity.Queries.by_actor(actor)
	\|> Activity.Queries.by_object_id(object)
	\|> where(fragment("data->>'state' = 'pending'") or fragment("data->>'state' = 'accept'"))
	\|> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
	\|> Repo.update_all([])

	activity = Activity.get_by_id(activity.id)

	{:ok, activity}
	end

	def update_follow_state(
	%Activity{} = activity,
	state
	) do
	new_data = Map.put(activity.data, "state", state)
	changeset = Changeset.change(activity, data: new_data)

	with {:ok, activity} <- Repo.update(changeset) do
	{:ok, activity}
	end
	end

	@doc """
	Makes a follow activity data for the given follower and followed
	"""
	def make_follow_data(
	%User{ap_id: follower_id},
	%User{ap_id: followed_id} = _followed,
	activity_id
	) do
	%{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"cc" => [Pleroma.Constants.as_public()],
	"object" => followed_id,
	"state" => "pending"
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
	"Follow"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^follower_id)
	# this is to use the index
	\|> Activity.Queries.by_object_id(followed_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def fetch_latest_undo(%User{ap_id: ap_id}) do
	"Undo"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^ap_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def get_latest_reaction(internal_activity_id, %{ap_id: ap_id}, emoji) do
	%{data: %{"object" => object_ap_id}} = Activity.get_by_id(internal_activity_id)
	emoji = Pleroma.Emoji.maybe_quote(emoji)

	"EmojiReact"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^ap_id)
	\|> custom_emoji_discriminator(emoji)
	\|> Activity.Queries.by_object_id(object_ap_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	defp custom_emoji_discriminator(query, emoji) do
	if String.contains?(emoji, "@") do
	stripped = Pleroma.Emoji.maybe_strip_name(emoji)
	[name, domain] = String.split(stripped, "@")
	domain_pattern = "%/" <> domain <> "/%"
	emoji_pattern = Pleroma.Emoji.maybe_quote(name)

	query
	\|> where([activity], fragment("?->>'content' = ?
	AND EXISTS (
	SELECT FROM jsonb_array_elements(?->'tag') elem
	WHERE elem->>'id' ILIKE ?
	)", activity.data, ^emoji_pattern, activity.data, ^domain_pattern))
	else
	query
	\|> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
	end
	end

	#### Announce-related helpers

	@doc """
	Returns an existing announce activity if the notice has already been announced
	"""
	@spec get_existing_announce(String.t(), map()) :: Activity.t() \| nil
	def get_existing_announce(actor, %{data: %{"id" => ap_id}}) do
	"Announce"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^actor)
	# this is to use the index
	\|> Activity.Queries.by_object_id(ap_id)
	\|> Repo.one()
	end

	@doc """
	Make announce activity data for the given actor and object
	"""
	# for relayed messages, we only want to send to subscribers
	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	false
	) do
	%{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address],
	"cc" => [],
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	true
	) do
	%{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => object.data["context"]
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	def make_undo_data(
	%User{ap_id: actor, follower_address: follower_address},
	%Activity{
	data: %{"id" => undone_activity_id, "context" => context},
	actor: undone_activity_actor
	},
	activity_id \\ nil
	) do
	%{
	"type" => "Undo",
	"actor" => actor,
	"object" => undone_activity_id,
	"to" => [follower_address, undone_activity_actor],
	"cc" => [Pleroma.Constants.as_public()],
	"context" => context
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	@spec add_announce_to_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def add_announce_to_object(
	%Activity{data: %{"actor" => actor}},
	object
	) do
	unless actor \|> User.get_cached_by_ap_id() \|> User.invisible?() do
	announcements = take_announcements(object)

	with announcements <- Enum.uniq([actor \| announcements]) do
	update_element_in_object("announcement", announcements, object)
	end
	else
	{:ok, object}
	end
	end

	def add_announce_to_object(_, object), do: {:ok, object}

	@spec remove_announce_from_object(Activity.t(), Object.t()) ::
	{:ok, Object.t()} \| {:error, Ecto.Changeset.t()}
	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	with announcements <- List.delete(take_announcements(object), actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	defp take_announcements(%{data: %{"announcements" => announcements}} = _)
	when is_list(announcements),
	do: announcements

	defp take_announcements(_), do: []

	#### Unfollow-related helpers

	#### Block-related helpers
	@spec fetch_latest_block(User.t(), User.t()) :: Activity.t() \| nil
	def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	"Block"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^blocker_id)
	# this is to use the index
	\|> Activity.Queries.by_object_id(blocked_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	end

	def make_block_data(blocker, blocked, activity_id) do
	%{
	"type" => "Block",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => blocked.ap_id
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	#### Flag-related helpers
	@spec make_flag_data(map(), map()) :: map()
	def make_flag_data(
	%{actor: actor, context: context, content: content} = params,
	additional
	) do
	%{
	"type" => "Flag",
	"actor" => actor.ap_id,
	"content" => content,
	"object" => build_flag_object(params),
	"context" => context,
	"state" => "open",
	"rules" => Map.get(params, :rules, nil)
	}
	\|> Map.merge(additional)
	end

	def make_flag_data(_, _), do: %{}

	defp build_flag_object(%{account: account, statuses: statuses}) do
	[account.ap_id \| build_flag_object(%{statuses: statuses})]
	end

	defp build_flag_object(%{statuses: statuses}) do
	Enum.map(statuses \|\| [], &build_flag_object/1)
	end

	defp build_flag_object(%Activity{} = activity) do
	object = Object.normalize(activity, fetch: false)

	# Do not allow people to report Creates. Instead, report the Object that is Created.
	if activity.data["type"] != "Create" do
	build_flag_object_with_actor_and_id(
	object,
	User.get_by_ap_id(activity.data["actor"]),
	activity.data["id"]
	)
	else
	build_flag_object(object)
	end
	end

	defp build_flag_object(%Object{} = object) do
	actor = User.get_by_ap_id(object.data["actor"])
	build_flag_object_with_actor_and_id(object, actor, object.data["id"])
	end

	defp build_flag_object(act) when is_map(act) or is_binary(act) do
	id =
	case act do
	%Activity{} = act -> act.data["id"]
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end

	case Activity.get_by_ap_id_with_object(id) do
	%Activity{object: object} = _ ->
	build_flag_object(object)

	nil ->
	case Object.get_by_ap_id(id) do
	%Object{} = object -> build_flag_object(object)
	_ -> %{"id" => id, "deleted" => true}
	end
	end
	end

	defp build_flag_object(_), do: []

	defp build_flag_object_with_actor_and_id(%Object{data: data}, actor, id) do
	%{
	"type" => "Note",
	"id" => id,
	"content" => data["content"],
	"published" => data["published"],
	"actor" =>
	AccountView.render(
	"show.json",
	%{user: actor, skip_visibility_check: true}
	)
	}
	end

	#### Report-related helpers
	def get_reports(params, page, page_size) do
	params =
	params
	\|> Map.put(:type, "Flag")
	\|> Map.put(:skip_preload, true)
	\|> Map.put(:preload_report_notes, true)
	\|> Map.put(:total, true)
	\|> Map.put(:limit, page_size)
	\|> Map.put(:offset, (page - 1) * page_size)

	ActivityPub.fetch_activities([], params, :offset)
	end

	defp maybe_strip_report_status(data, state) do
	with true <- Config.get([:instance, :report_strip_status]),
	true <- state in @strip_status_report_states,
	{:ok, stripped_activity} = strip_report_status_data(%Activity{data: data}) do
	data \|> Map.put("object", stripped_activity.data["object"])
	else
	_ -> data
	end
	end

	def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
	new_data =
	activity.data
	\|> Map.put("state", state)
	\|> maybe_strip_report_status(state)

	activity
	\|> Changeset.change(data: new_data)
	\|> Repo.update()
	end

	def update_report_state(activity_ids, state) when state in @supported_report_states do
	activities_num = length(activity_ids)

	from(a in Activity, where: a.id in ^activity_ids)
	\|> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
	\|> Repo.update_all([])
	\|> case do
	{^activities_num, _} -> :ok
	_ -> {:error, activity_ids}
	end
	end

	def update_report_state(_, _), do: {:error, "Unsupported state"}

	def assign_report_to_account(%Activity{} = activity, nil = _account) do
	new_data = Map.delete(activity.data, "assigned_account")

	activity
	\|> Changeset.change(data: new_data)
	\|> Repo.update()
	end

	def assign_report_to_account(%Activity{} = activity, account) do
	new_data = Map.put(activity.data, "assigned_account", account)

	activity
	\|> Changeset.change(data: new_data)
	\|> Repo.update()
	end

	def assign_report_to_account(activity_ids, account) do
	activities_num = length(activity_ids)

	from(a in Activity, where: a.id in ^activity_ids)
	\|> update(set: [data: fragment("jsonb_set(data, '{assigned_account}', ?)", ^account)])
	\|> Repo.update_all([])
	\|> case do
	{^activities_num, _} -> :ok
	_ -> {:error, activity_ids}
	end
	end

	def strip_report_status_data(%Activity{} = activity) do
	with {:ok, new_data} <- strip_report_status_data(activity.data) do
	{:ok, %{activity \| data: new_data}}
	end
	end

	def strip_report_status_data(data) do
	[actor \| reported_activities] = data["object"]

	stripped_activities =
	Enum.reduce(reported_activities, [], fn act, acc ->
	case ObjectID.cast(act) do
	{:ok, act} -> [act \| acc]
	_ -> acc
	end
	end)

	new_data = put_in(data, ["object"], [actor \| stripped_activities])

	{:ok, new_data}
	end

	def get_anonymized_reporter do
	with true <- Pleroma.Config.get([:activitypub, :anonymize_reporter]),
	nickname when is_binary(nickname) <-
	Pleroma.Config.get([:activitypub, :anonymize_reporter_local_nickname]),
	%User{ap_id: ap_id, local: true} <- User.get_cached_by_nickname(nickname) do
	ap_id
	else
	_ -> nil
	end
	end

	def maybe_anonymize_reporter(%Activity{data: data} = activity) do
	new_data = maybe_anonymize_reporter(data)
	%Activity{activity \| actor: new_data["actor"], data: new_data}
	end

	def maybe_anonymize_reporter(activity) do
	ap_id = get_anonymized_reporter()

	if is_binary(ap_id) do
	activity
	\|> Map.put("actor", ap_id)
	else
	activity
	end
	end

	def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
	[to, cc, recipients] =
	activity
	\|> get_updated_targets(visibility)
	\|> Enum.map(&Enum.uniq/1)

	object_data =
	activity.object.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

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

	activity_data =
	activity.data
	\|> Map.put("to", to)
	\|> Map.put("cc", cc)

	activity
	\|> Map.put(:object, object)
	\|> Activity.change(%{data: activity_data, recipients: recipients})
	\|> Repo.update()
	end

	def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}

	defp get_updated_targets(
	%Activity{data: %{"to" => to} = data, recipients: recipients},
	visibility
	) do
	cc = Map.get(data, "cc", [])
	follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
	public = Pleroma.Constants.as_public()

	case visibility do
	"public" ->
	to = [public \| List.delete(to, follower_address)]
	cc = [follower_address \| List.delete(cc, public)]
	recipients = [public \| recipients]
	[to, cc, recipients]

	"private" ->
	to = [follower_address \| List.delete(to, public)]
	cc = List.delete(cc, public)
	recipients = List.delete(recipients, public)
	[to, cc, recipients]

	"unlisted" ->
	to = [follower_address \| List.delete(to, public)]
	cc = [public \| List.delete(cc, follower_address)]
	recipients = recipients ++ [follower_address, public]
	[to, cc, recipients]

	_ ->
	[to, cc, recipients]
	end
	end

	def get_existing_votes(actor, %{data: %{"id" => id}}) do
	actor
	\|> Activity.Queries.by_actor()
	\|> Activity.Queries.by_type("Create")
	\|> Activity.with_preloaded_object()
	\|> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
	\|> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
	\|> Repo.all()
	end

	@spec maybe_handle_group_posts(Activity.t()) :: :ok
	@doc "Automatically repeats posts for local group actor recipients"
	def maybe_handle_group_posts(activity) do
	poster = User.get_cached_by_ap_id(activity.actor)

	User.get_recipients_from_activity(activity)
	\|> Enum.filter(&match?("Group", &1.actor_type))
	\|> Enum.reject(&User.blocks?(&1, poster))
	\|> Enum.each(&Pleroma.Web.CommonAPI.repeat(activity.id, &1))
	end
	end
	diff --git a/lib/pleroma/web/common_api/activity_draft.ex b/lib/pleroma/web/common_api/activity_draft.ex
	index 25bf590aa..2427d1298 100644
	--- a/lib/pleroma/web/common_api/activity_draft.ex
	+++ b/lib/pleroma/web/common_api/activity_draft.ex
	@@ -1,412 +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.CommonAPI.ActivityDraft do
	alias Pleroma.Activity
	alias Pleroma.Conversation.Participation
	alias Pleroma.Language.LanguageDetector
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Utils, as: ActivityPubUtils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils

	import Pleroma.EctoType.ActivityPub.ObjectValidators.LanguageCode,
	only: [good_locale_code?: 1]

	import Pleroma.Web.Gettext
	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

	@type t :: %__MODULE__{}

	defstruct valid?: true,
	errors: [],
	user: nil,
	params: %{},
	status: nil,
	summary: nil,
	full_payload: nil,
	attachments: [],
	in_reply_to: nil,
	in_reply_to_conversation: nil,
	quote_post: nil,
	visibility: nil,
	expires_at: nil,
	extra: nil,
	emoji: %{},
	content_html: nil,
	mentions: [],
	tags: [],
	to: [],
	cc: [],
	context: nil,
	sensitive: false,
	language: nil,
	object: nil,
	preview?: false,
	changes: %{}

	def new(user, params) do
	%__MODULE__{user: user}
	\|> put_params(params)
	end

	def create(user, params) do
	user
	\|> new(params)
	\|> status()
	\|> summary()
	\|> with_valid(&attachments/1)
	\|> full_payload()
	\|> expires_at()
	\|> poll()
	\|> with_valid(&in_reply_to/1)
	\|> with_valid(&in_reply_to_conversation/1)
	\|> with_valid(&quote_post/1)
	\|> with_valid(&visibility/1)
	\|> with_valid(&quoting_visibility/1)
	\|> content()
	\|> with_valid(&to_and_cc/1)
	\|> with_valid(&context/1)
	\|> with_valid(&language/1)
	\|> sensitive()
	\|> with_valid(&object/1)
	\|> preview?()
	\|> with_valid(&changes/1)
	\|> validate()
	end

	def listen(user, params) do
	user
	\|> new(params)
	\|> visibility()
	\|> to_and_cc()
	\|> context()
	\|> listen_object()
	\|> with_valid(&listen_changes/1)
	\|> validate()
	end

	defp listen_object(%__MODULE__{} = draft) do
	object =
	draft.params
	\|> Map.take([:album, :artist, :title, :length])
	\|> Map.put(:externalLink, Map.get(draft.params, :external_link))
	\|> Map.new(fn {key, value} -> {to_string(key), value} end)
	\|> Map.put("id", ActivityPubUtils.generate_object_id())
	\|> Map.put("type", "Audio")
	\|> Map.put("published", ActivityPubUtils.make_date())
	\|> Map.put("to", draft.to)
	\|> Map.put("cc", draft.cc)
	\|> Map.put("actor", draft.user.ap_id)
	\|> Map.put("context", draft.context)

	%{draft \| object: object}
	end

	defp put_params(%__MODULE__{} = draft, params) do
	params = Map.put_new(params, :in_reply_to_status_id, params[:in_reply_to_id])
	%{draft \| params: params}
	end

	defp status(%__MODULE__{params: %{status: status}} = draft) do
	%{draft \| status: String.trim(status)}
	end

	defp summary(%__MODULE__{params: params} = draft) do
	%{draft \| summary: Map.get(params, :spoiler_text, "")}
	end

	defp full_payload(%__MODULE__{status: status, summary: summary} = draft) do
	full_payload = String.trim(status <> summary)

	case Utils.validate_character_limit(full_payload, draft.attachments) do
	:ok -> %{draft \| full_payload: full_payload}
	{:error, message} -> add_error(draft, message)
	end
	end

	defp attachments(%__MODULE__{params: params} = draft) do
	attachments = Utils.attachments_from_ids(params, draft.user)
	draft = %{draft \| attachments: attachments}

	case Utils.validate_attachments_count(attachments) do
	:ok -> draft
	{:error, message} -> add_error(draft, message)
	end
	end

	defp in_reply_to(%__MODULE__{params: %{in_reply_to_status_id: ""}} = draft), do: draft

	defp in_reply_to(%__MODULE__{params: %{in_reply_to_status_id: id}} = draft)
	when is_binary(id) do
	# If a post was deleted all its activities (except the newly added Delete) are purged too,
	# thus lookup by Create db ID will yield nil just as if it never existed in the first place.
	#
	# We allow replying to Announce here, due to a Pleroma-FE quirk where if presented with
	# an Announce id it will render it as if it was just the normal referenced post, but
	# use the Announce id for replies in the in_reply_to_id key of a POST request to
	# /api/v1/statuses, or as an :id in /api/v1/statuses/:id/*.
	# TODO: Fix this quirk in FE and remove here and other affected places
	with %Activity{} = activity <- Activity.get_by_id(id),
	true <- Visibility.visible_for_user?(activity, draft.user),
	{_, type} when type in ["Create", "Announce"] <- {:type, activity.data["type"]} do
	%{draft \| in_reply_to: activity}
	else
	nil ->
	add_error(draft, dgettext("errors", "Cannot reply to a deleted status"))

	false ->
	add_error(draft, dgettext("errors", "Record not found"))

	{:type, type} ->
	add_error(
	draft,
	dgettext("errors", "Can only reply to posts, not %{type} activities",
	type: inspect(type)
	)
	)
	end
	end

	defp in_reply_to(
	%__MODULE__{params: %{in_reply_to_status_id: %Activity{} = in_reply_to}} = draft
	) do
	%{draft \| in_reply_to: in_reply_to}
	end

	defp in_reply_to(draft), do: draft

	defp quote_post(%__MODULE__{params: %{quoted_status_id: id}} = draft)
	when not_empty_string(id) do
	case Activity.get_by_id_with_object(id) do
	%Activity{} = activity ->
	%{draft \| quote_post: activity}

	_ ->
	draft
	end
	end

	defp quote_post(%__MODULE__{params: %{quote_id: id}} = draft) when not_empty_string(id) do
	quote_post(%{draft \| params: Map.put(draft.params, :quoted_status_id, id)})
	end

	defp quote_post(draft), do: draft

	defp in_reply_to_conversation(%__MODULE__{} = draft) do
	in_reply_to_conversation = Participation.get(draft.params[:in_reply_to_conversation_id])
	%{draft \| in_reply_to_conversation: in_reply_to_conversation}
	end

	defp visibility(%__MODULE__{params: params} = draft) do
	case CommonAPI.get_visibility(params, draft.in_reply_to, draft.in_reply_to_conversation) do
	{visibility, "direct"} when visibility != "direct" ->
	add_error(draft, dgettext("errors", "The message visibility must be direct"))

	{visibility, _} ->
	%{draft \| visibility: visibility}
	end
	end

	defp can_quote?(_draft, _object, visibility) when visibility in ~w(public unlisted local) do
	true
	end

	defp can_quote?(draft, object, "private") do
	draft.user.ap_id == object.data["actor"]
	end

	defp can_quote?(_, _, _) do
	false
	end

	defp quoting_visibility(%__MODULE__{quote_post: %Activity{}} = draft) do
	with %Object{} = object <- Object.normalize(draft.quote_post, fetch: false),
	true <- can_quote?(draft, object, Visibility.get_visibility(object)) do
	draft
	else
	_ -> add_error(draft, dgettext("errors", "Cannot quote private message"))
	end
	end

	defp quoting_visibility(draft), do: draft

	defp expires_at(%__MODULE__{} = draft) do
	case CommonAPI.check_expiry_date(draft.params[:expires_in]) do
	{:ok, expires_at} -> %{draft \| expires_at: expires_at}
	{:error, message} -> add_error(draft, message)
	end
	end

	defp poll(%__MODULE__{} = draft) do
	case Utils.make_poll_data(draft.params) do
	{:ok, {poll, poll_emoji}} ->
	%{draft \| extra: poll, emoji: Map.merge(draft.emoji, poll_emoji)}

	{:error, message} ->
	add_error(draft, message)
	end
	end

	defp content(%__MODULE__{mentions: mentions} = draft) do
	{content_html, mentioned_users, tags} = Utils.make_content_html(draft)

	mentioned_ap_ids =
	Enum.map(mentioned_users, fn {_, mentioned_user} -> mentioned_user.ap_id end)

	mentions =
	mentions
	\|> Kernel.++(mentioned_ap_ids)
	\|> Utils.get_addressed_users(draft.params[:to])

	%{draft \| content_html: content_html, mentions: mentions, tags: tags}
	end

	defp to_and_cc(%__MODULE__{} = draft) do
	{to, cc} = Utils.get_to_and_cc(draft)

	- # Objects must be addressed to someone. Direct messages without mentions
	- # are addressed to their author, who is a recipient anyway.
	+ # The validators require objects to be addressed to someone. Direct
	+ # messages without mentions are addressed to their author.
	cc = if to == [] and cc == [], do: [draft.user.ap_id], else: cc

	%{draft \| to: to, cc: cc}
	end

	defp context(%__MODULE__{} = draft) do
	context = Utils.make_context(draft.in_reply_to, draft.in_reply_to_conversation)
	%{draft \| context: context}
	end

	defp sensitive(%__MODULE__{} = draft) do
	sensitive = draft.params[:sensitive]
	%{draft \| sensitive: sensitive}
	end

	defp language(%__MODULE__{} = draft) do
	language =
	with language <- draft.params[:language],
	true <- good_locale_code?(language) do
	language
	else
	_ -> LanguageDetector.detect(draft.content_html <> " " <> draft.summary)
	end

	%{draft \| language: language}
	end

	defp object(%__MODULE__{} = draft) do
	emoji = Map.merge(Pleroma.Emoji.Formatter.get_emoji_map(draft.full_payload), draft.emoji)

	# Sometimes people create posts with subject containing emoji,
	# since subjects are usually copied this will result in a broken
	# subject when someone replies from an instance that does not have
	# the emoji or has it under different shortcode. This is an attempt
	# to mitigate this by copying emoji from inReplyTo if they are present
	# in the subject.
	summary_emoji =
	with %Activity{} <- draft.in_reply_to,
	%Object{data: %{"tag" => [_ \| _] = tag}} <- Object.normalize(draft.in_reply_to) do
	Enum.reduce(tag, %{}, fn
	%{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}, acc ->
	if String.contains?(draft.summary, name) do
	Map.put(acc, name, url)
	else
	acc
	end

	_, acc ->
	acc
	end)
	else
	_ -> %{}
	end

	emoji = Map.merge(emoji, summary_emoji)

	media_type = Utils.get_content_type(draft.params[:content_type])
	{:ok, note_data, _meta} = Builder.note(draft)

	object =
	note_data
	\|> Map.put("emoji", emoji)
	\|> Map.put("source", %{
	"content" => draft.status,
	"mediaType" => media_type
	})
	\|> maybe_put("htmlMfm", true, media_type == "text/x.misskeymarkdown")
	\|> maybe_put("directMessage", true, draft.visibility == "direct")
	\|> Map.put("generator", draft.params[:generator])
	\|> Map.put("language", draft.language)

	%{draft \| object: object}
	end

	defp maybe_put(map, key, value, true), do: Map.put(map, key, value)
	defp maybe_put(map, _key, _value, _condition), do: map

	defp preview?(%__MODULE__{} = draft) do
	preview? = Pleroma.Web.Utils.Params.truthy_param?(draft.params[:preview])
	%{draft \| preview?: preview?}
	end

	# Builds the Create activity for the pipeline.
	defp changes(%__MODULE__{} = draft) do
	{:ok, create_data, _meta} = Builder.create(draft.user, draft.object, draft.to)

	changes =
	create_data
	\|> Map.put("cc", draft.cc)
	\|> Map.put("directMessage", draft.visibility == "direct")
	\|> maybe_put_expires_at(draft.expires_at)
	\|> maybe_add_list_data(draft.user, draft.visibility)

	%{draft \| changes: changes}
	end

	defp maybe_put_expires_at(data, %DateTime{} = expires_at),
	do: Map.put(data, "expires_at", DateTime.to_iso8601(expires_at))

	defp maybe_put_expires_at(data, _), do: data

	defp maybe_add_list_data(data, user, {:list, list_id}) do
	case Pleroma.List.get(list_id, user) do
	%Pleroma.List{ap_id: list_ap_id} ->
	data
	\|> Map.put("bcc", [list_ap_id])
	\|> Map.put("listMessage", list_ap_id)
	\|> put_in(["object", "bcc"], [list_ap_id])
	\|> put_in(["object", "listMessage"], list_ap_id)

	_ ->
	data
	end
	end

	defp maybe_add_list_data(data, _user, _visibility), do: data

	# Builds the Listen activity for the pipeline.
	defp listen_changes(%__MODULE__{} = draft) do
	{:ok, listen_data, _meta} = Builder.listen(draft.user, draft.object, draft.to)

	changes =
	listen_data
	\|> Map.put("cc", draft.cc)
	\|> Map.put("directMessage", draft.visibility == "direct")
	\|> maybe_add_list_data(draft.user, draft.visibility)

	%{draft \| changes: changes}
	end

	defp with_valid(%{valid?: true} = draft, func), do: func.(draft)
	defp with_valid(draft, _func), do: draft

	defp add_error(%__MODULE__{} = draft, message) do
	%{draft \| valid?: false, errors: [message \| draft.errors]}
	end

	defp validate(%{valid?: true} = draft), do: {:ok, draft}
	defp validate(%{errors: [message \| _]}), do: {:error, message}
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 30, 4:30 PM (15 h, 48 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1800300
Default Alt Text: (42 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions