No OneTemporary
Actions

Size

55 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 909e6afe6..5342d32a4 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,991 +1,991 @@
	# 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.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

	require Logger
	require Pleroma.Constants

	@supported_object_types [
	"Article",
	"Note",
	"Event",
	"Video",
	"Page",
	"Question",
	"Answer",
	"Audio"
	]
	@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?(&is_nil(&1))

	@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 pleroma_ns do
	"https://docs-develop.pleroma.social/backend/ns#"
	end

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"#{Endpoint.url()}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und",
	"pleroma" => pleroma_ns(),
	"avatarStyle" => "pleroma:avatarStyle"
	}
	]
	}
	end

	def parse_json_ld_context(object) do
	table = parse_json_ld_context_impl(Map.get(object, "@context", []), %{})

	Map.keys(table)
	\|> Enum.reduce(%{}, fn key, acc ->
	[full \| short_forms] = table[key]
	Map.put(acc, full, Map.get(acc, full, []) ++ [key, full \| short_forms])
	end)
	end

	defp parse_json_ld_context_impl([context \| tail], acc) when is_map(context) do
	next =
	Map.keys(context)
	\|> Enum.reduce(acc, fn key, acc ->
	definition =
	if is_map(context[key]) do
	Map.get(context[key], "@id", "")
	else
	context[key]
	end

	definition_string =
	if is_binary(definition) do
	definition
	else
	""
	end

	parts = String.split(definition_string, ":", parts: 2)

	expanded =
	if length(parts) == 1 do
	definition_string
	else
	[scheme, rest] = parts
	scheme_def = Map.get(acc, scheme, Map.get(context, scheme, scheme <> ":"))
	scheme_def <> rest
	end

	# Expand it one time only
	# for example, {"pleroma": pleroma_ns(), "xxx": "pleroma:xxx"}
	# is turned into: ("xxx") => ["pleroma:xxx", pleroma_ns() <> "xxx"]
	if definition_string == expanded do
	Map.put(acc, key, [expanded])
	else
	Map.put(acc, key, [expanded, definition_string])
	end
	- end)
	+ end)

	parse_json_ld_context_impl(tail, next)
	end

	defp parse_json_ld_context_impl([_ \| tail], acc) do
	parse_json_ld_context_impl(tail, acc)
	end

	defp parse_json_ld_context_impl([], acc) do
	acc
	end

	defp parse_json_ld_context_impl(context, acc) do
	parse_json_ld_context_impl([context], acc)
	end

	def lookup_json_ld_key(object, context, key) do
	attr_names = Map.get(context, key, [key])

	if is_nil(attr_names) do
	{:not_found, nil}
	else
	attr_names
	\|> Enum.reduce_while({:not_found, nil}, fn name, _acc ->
	if Map.has_key?(object, name) do
	{:halt, {:ok, Map.get(object, name)}}
	else
	{:cont, {:not_found, nil}}
	end
	end)
	end
	end

	def inject_json_ld_context(matrix_object, embedded_object) do
	to_list_like = fn
	list when is_list(list) -> list
	atom -> [atom]
	end

	merged_json_ld_context =
	to_list_like.(Map.get(matrix_object, "@context", [])) ++
	to_list_like.(Map.get(embedded_object, "@context", []))

	embedded_object
	\|> Map.put("@context", merged_json_ld_context)
	end

	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 create_context(context) do
	context = context \|\| generate_id("contexts")

	# Ecto has problems accessing the constraint inside the jsonb,
	# so we explicitly check for the existed object before insert
	object = Object.get_cached_by_ap_id(context)

	with true <- is_nil(object),
	changeset <- Object.context_mapping(context),
	{:ok, inserted_object} <- Repo.insert(changeset) do
	inserted_object
	else
	_ ->
	object
	end
	end

	@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.is_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")
	\|> Map.put_new("context_id", -1)
	\|> lazy_put_object_defaults(true)
	end

	def lazy_put_activity_defaults(map, _fake?) do
	%{data: %{"id" => context}, id: context_id} = 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)
	\|> Map.put_new("context_id", context_id)
	\|> 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("context_id", activity["context_id"])
	\|> 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"])
	\|> Map.put_new("context_id", activity["context_id"])

	%{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.is_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}},
	object
	) do
	reactions = get_cached_emoji_reactions(object)

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

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

	count = emoji_count(new_reactions)

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

	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}},
	object
	) do
	reactions = get_cached_emoji_reactions(object)

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

	index ->
	List.update_at(
	reactions,
	index,
	fn [emoji, users] -> [emoji, List.delete(users, actor)] 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
	if is_list(object.data["reactions"]) do
	object.data["reactions"]
	else
	[]
	end
	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)

	"EmojiReact"
	\|> Activity.Queries.by_type()
	\|> where(actor: ^ap_id)
	\|> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
	\|> Activity.Queries.by_object_id(object_ap_id)
	\|> order_by([activity], fragment("? desc nulls last", activity.id))
	\|> limit(1)
	\|> Repo.one()
	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

	def make_unfollow_data(follower, followed, follow_activity, activity_id) do
	%{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	"object" => follow_activity.data
	}
	\|> Maps.put_if_present("id", activity_id)
	end

	#### 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

	#### Create-related helpers

	def make_create_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	#### Listen-related helpers
	def make_listen_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Listen",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	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"
	}
	\|> 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{data: %{"id" => id}, object: %{data: data}}) do
	activity_actor = User.get_by_ap_id(data["actor"])

	%{
	"type" => "Note",
	"id" => id,
	"content" => data["content"],
	"published" => data["published"],
	"actor" =>
	AccountView.render(
	"show.json",
	%{user: activity_actor, skip_visibility_check: true}
	)
	}
	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{} = activity ->
	build_flag_object(activity)

	nil ->
	if activity = Activity.get_by_object_ap_id_with_object(id) do
	build_flag_object(activity)
	else
	%{"id" => id, "deleted" => true}
	end
	end
	end

	defp build_flag_object(_), do: []

	#### 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

	def update_report_state(%Activity{} = activity, state)
	when state in @strip_status_report_states do
	{:ok, stripped_activity} = strip_report_status_data(activity)

	new_data =
	activity.data
	\|> Map.put("state", state)
	\|> Map.put("object", stripped_activity.data["object"])

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

	def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
	new_data = Map.put(activity.data, "state", 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 strip_report_status_data(activity) do
	[actor \| reported_activities] = activity.data["object"]

	stripped_activities =
	Enum.map(reported_activities, fn
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end)

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

	{:ok, %{activity \| data: new_data}}
	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
	end
	diff --git a/test/pleroma/web/activity_pub/mrf/actor_avatar_style_policy_test.exs b/test/pleroma/web/activity_pub/mrf/actor_avatar_style_policy_test.exs
	index 36b294d40..31961308e 100644
	--- a/test/pleroma/web/activity_pub/mrf/actor_avatar_style_policy_test.exs
	+++ b/test/pleroma/web/activity_pub/mrf/actor_avatar_style_policy_test.exs
	@@ -1,52 +1,58 @@
	# 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.MRF.ActorAvatarStylePolicyTest do
	use Pleroma.DataCase, async: true
	import Pleroma.Factory

	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.MRF.ActorAvatarStylePolicy
	alias Pleroma.Web.ActivityPub.Utils

	describe "turns isCat into avatarStyle" do
	test "with Update activity" do
	actor = insert(:user, %{local: false})

	- {:ok, message, _} = Builder.update(
	- actor,
	- %{
	- "id" => actor.ap_id,
	- "type" => "Person",
	- "name" => "some name",
	- "isCat" => true
	- })
	+ {:ok, message, _} =
	+ Builder.update(
	+ actor,
	+ %{
	+ "id" => actor.ap_id,
	+ "type" => "Person",
	+ "name" => "some name",
	+ "isCat" => true
	+ }
	+ )

	assert {:ok, filtered} = ActorAvatarStylePolicy.filter(message)

	context = Utils.parse_json_ld_context(filtered)
	- {:ok, avatar_style} = Utils.lookup_json_ld_key(filtered["object"], context, Utils.pleroma_ns() <> "avatarStyle")
	+
	+ {:ok, avatar_style} =
	+ Utils.lookup_json_ld_key(filtered["object"], context, Utils.pleroma_ns() <> "avatarStyle")

	assert avatar_style == "🐈"
	end

	test "with Person object" do
	actor = insert(:user, %{local: false})

	message = %{
	"id" => actor.ap_id,
	"type" => "Person",
	"name" => "some name",
	"isCat" => true
	}

	assert {:ok, filtered} = ActorAvatarStylePolicy.filter(message)

	context = Utils.parse_json_ld_context(filtered)
	- {:ok, avatar_style} = Utils.lookup_json_ld_key(filtered, context, Utils.pleroma_ns() <> "avatarStyle")
	+
	+ {:ok, avatar_style} =
	+ Utils.lookup_json_ld_key(filtered, context, Utils.pleroma_ns() <> "avatarStyle")

	assert avatar_style == "🐈"
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/utils_test.exs b/test/pleroma/web/activity_pub/utils_test.exs
	index 28135a629..a6efc5def 100644
	--- a/test/pleroma/web/activity_pub/utils_test.exs
	+++ b/test/pleroma/web/activity_pub/utils_test.exs
	@@ -1,665 +1,696 @@
	# 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.UtilsTest do
	use Pleroma.DataCase, async: true
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	require Pleroma.Constants

	describe "fetch the latest Follow" do
	test "fetches the latest Follow activity" do
	%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	follower = User.get_cached_by_ap_id(activity.data["actor"])
	followed = User.get_cached_by_ap_id(activity.data["object"])

	assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "determine_explicit_mentions()" do
	test "works with an object that has mentions" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that does not have mentions" do
	object = %{
	"tag" => [
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has mentions and other tags" do
	object = %{
	"tag" => [
	%{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	},
	%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
	]
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end

	test "works with an object that has no tags" do
	object = %{}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object that has only IR tags" do
	object = %{"tag" => ["2hu"]}

	assert Utils.determine_explicit_mentions(object) == []
	end

	test "works with an object has tags as map" do
	object = %{
	"tag" => %{
	"type" => "Mention",
	"href" => "https://example.com/~alyssa",
	"name" => "Alyssa P. Hacker"
	}
	}

	assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
	end
	end

	describe "make_like_data" do
	setup do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	[user: user, other_user: other_user, third_user: third_user]
	end

	test "addresses actor's follower address if the activity is public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id, other_user.follower_address])
	expected_cc = Enum.sort(["https://www.w3.org/ns/activitystreams#Public", third_user.ap_id])

	{:ok, activity} =
	CommonAPI.post(user, %{
	status:
	"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end

	test "does not adress actor's follower address if the activity is not public", %{
	user: user,
	other_user: other_user,
	third_user: third_user
	} do
	expected_to = Enum.sort([user.ap_id])
	expected_cc = [third_user.ap_id]

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
	visibility: "private"
	})

	%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
	assert Enum.sort(to) == expected_to
	assert Enum.sort(cc) == expected_cc
	end
	end

	test "make_json_ld_header/0" do
	assert Utils.make_json_ld_header() == %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"http://localhost:4001/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und",
	"pleroma" => Utils.pleroma_ns(),
	"avatarStyle" => "pleroma:avatarStyle"
	}
	]
	}
	end

	describe "get_existing_votes" do
	test "fetches existing votes" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "How do I pronounce LaTeX?",
	poll: %{
	options: ["laytekh", "lahtekh", "latex"],
	expires_in: 20,
	multiple: true
	}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, votes, object} = CommonAPI.vote(other_user, object, [0, 1])
	assert Enum.sort(Utils.get_existing_votes(other_user.ap_id, object)) == Enum.sort(votes)
	end

	test "fetches only Create activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{
	status: "Are we living in a society?",
	poll: %{
	options: ["yes", "no"],
	expires_in: 20
	}
	})

	object = Object.normalize(activity, fetch: false)
	{:ok, [vote], object} = CommonAPI.vote(other_user, object, [0])
	{:ok, _activity} = CommonAPI.favorite(user, activity.id)
	[fetched_vote] = Utils.get_existing_votes(other_user.ap_id, object)
	assert fetched_vote.id == vote.id
	end
	end

	describe "update_follow_state_for_all/2" do
	test "updates the state of all Follow activities with the same actor and object" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "accept")

	assert refresh_record(follow_activity).data["state"] == "accept"
	assert refresh_record(follow_activity_two).data["state"] == "accept"
	end

	test "also updates the state of accepted follows" do
	user = insert(:user)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)

	{:ok, follow_activity_two} =
	Utils.update_follow_state_for_all(follow_activity_two, "reject")

	assert refresh_record(follow_activity).data["state"] == "reject"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_follow_state/2" do
	test "updates the state of the given follow activity" do
	user = insert(:user, is_locked: true)
	follower = insert(:user)

	{:ok, _, _, follow_activity} = CommonAPI.follow(follower, user)
	{:ok, _, _, follow_activity_two} = CommonAPI.follow(follower, user)

	data =
	follow_activity_two.data
	\|> Map.put("state", "accept")

	cng = Ecto.Changeset.change(follow_activity_two, data: data)

	{:ok, follow_activity_two} = Repo.update(cng)

	{:ok, follow_activity_two} = Utils.update_follow_state(follow_activity_two, "reject")

	assert refresh_record(follow_activity).data["state"] == "pending"
	assert refresh_record(follow_activity_two).data["state"] == "reject"
	end
	end

	describe "update_element_in_object/3" do
	test "updates likes" do
	user = insert(:user)
	activity = insert(:note_activity)
	object = Object.normalize(activity, fetch: false)

	assert {:ok, updated_object} =
	Utils.update_element_in_object(
	"like",
	[user.ap_id],
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "add_like_to_object/2" do
	test "add actor to likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note)

	assert {:ok, updated_object} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user.ap_id]
	assert updated_object.data["like_count"] == 1

	assert {:ok, updated_object2} =
	Utils.add_like_to_object(
	%Activity{data: %{"actor" => user2.ap_id}},
	updated_object
	)

	assert updated_object2.data["likes"] == [user2.ap_id, user.ap_id]
	assert updated_object2.data["like_count"] == 2
	end
	end

	describe "remove_like_from_object/2" do
	test "removes ap_id from likes" do
	user = insert(:user)
	user2 = insert(:user)
	object = insert(:note, data: %{"likes" => [user.ap_id, user2.ap_id], "like_count" => 2})

	assert {:ok, updated_object} =
	Utils.remove_like_from_object(
	%Activity{data: %{"actor" => user.ap_id}},
	object
	)

	assert updated_object.data["likes"] == [user2.ap_id]
	assert updated_object.data["like_count"] == 1
	end
	end

	describe "get_existing_like/2" do
	test "fetches existing like" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity, fetch: false)

	user = insert(:user)
	refute Utils.get_existing_like(user.ap_id, object)
	{:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)

	assert ^like_activity = Utils.get_existing_like(user.ap_id, object)
	end
	end

	describe "get_get_existing_announce/2" do
	test "returns nil if announce not found" do
	actor = insert(:user)
	refute Utils.get_existing_announce(actor.ap_id, %{data: %{"id" => "test"}})
	end

	test "fetches existing announce" do
	note_activity = insert(:note_activity)
	assert object = Object.normalize(note_activity, fetch: false)
	actor = insert(:user)

	{:ok, announce} = CommonAPI.repeat(note_activity.id, actor)
	assert Utils.get_existing_announce(actor.ap_id, object) == announce
	end
	end

	describe "fetch_latest_block/2" do
	test "fetches last block activities" do
	user1 = insert(:user)
	user2 = insert(:user)

	assert {:ok, %Activity{} = _} = CommonAPI.block(user1, user2)
	assert {:ok, %Activity{} = _} = CommonAPI.block(user1, user2)
	assert {:ok, %Activity{} = activity} = CommonAPI.block(user1, user2)

	assert Utils.fetch_latest_block(user1, user2) == activity
	end
	end

	describe "recipient_in_message/3" do
	test "returns true when recipient in `to`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"to" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"to" => [recipient.ap_id], "cc" => ""}
	)
	end

	test "returns true when recipient in `cc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"cc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"cc" => [recipient.ap_id], "to" => ""}
	)
	end

	test "returns true when recipient in `bto`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bto" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bcc" => "", "bto" => [recipient.ap_id]}
	)
	end

	test "returns true when recipient in `bcc`" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bcc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"bto" => "", "bcc" => [recipient.ap_id]}
	)
	end

	test "returns true when message without addresses fields" do
	recipient = insert(:user)
	actor = insert(:user)
	assert Utils.recipient_in_message(recipient, actor, %{"bccc" => recipient.ap_id})

	assert Utils.recipient_in_message(
	recipient,
	actor,
	%{"btod" => "", "bccc" => [recipient.ap_id]}
	)
	end

	test "returns false" do
	recipient = insert(:user)
	actor = insert(:user)
	refute Utils.recipient_in_message(recipient, actor, %{"to" => "ap_id"})
	end
	end

	describe "lazy_put_activity_defaults/2" do
	test "returns map with id and published data" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)
	res = Utils.lazy_put_activity_defaults(%{"context" => object.data["id"]})
	assert res["context"] == object.data["id"]
	assert res["context_id"] == object.id
	assert res["id"]
	assert res["published"]
	end

	test "returns map with fake id and published data" do
	assert %{
	"context" => "pleroma:fakecontext",
	"context_id" => -1,
	"id" => "pleroma:fakeid",
	"published" => _
	} = Utils.lazy_put_activity_defaults(%{}, true)
	end

	test "returns activity data with object" do
	note_activity = insert(:note_activity)
	object = Object.normalize(note_activity, fetch: false)

	res =
	Utils.lazy_put_activity_defaults(%{
	"context" => object.data["id"],
	"object" => %{}
	})

	assert res["context"] == object.data["id"]
	assert res["context_id"] == object.id
	assert res["id"]
	assert res["published"]
	assert res["object"]["id"]
	assert res["object"]["published"]
	assert res["object"]["context"] == object.data["id"]
	assert res["object"]["context_id"] == object.id
	end
	end

	describe "make_flag_data" do
	test "returns empty map when params is invalid" do
	assert Utils.make_flag_data(%{}, %{}) == %{}
	end

	test "returns map with Flag object" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{status: "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"

	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]

	res =
	Utils.make_flag_data(
	%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [%{"id" => activity.data["id"]}],
	content: content
	},
	%{}
	)

	note_obj = %{
	"type" => "Note",
	"id" => activity_ap_id,
	"content" => content,
	"published" => activity.object.data["published"],
	"actor" =>
	AccountView.render("show.json", %{user: target_account, skip_visibility_check: true})
	}

	assert %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^note_obj],
	"state" => "open"
	} = res
	end
	end

	describe "add_announce_to_object/2" do
	test "adds actor to announcement" do
	user = insert(:user)
	object = insert(:note)

	activity =
	insert(:note_activity,
	data: %{
	"actor" => user.ap_id,
	"cc" => [Pleroma.Constants.as_public()]
	}
	)

	assert {:ok, updated_object} = Utils.add_announce_to_object(activity, object)
	assert updated_object.data["announcements"] == [user.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "remove_announce_from_object/2" do
	test "removes actor from announcements" do
	user = insert(:user)
	user2 = insert(:user)

	object =
	insert(:note,
	data: %{"announcements" => [user.ap_id, user2.ap_id], "announcement_count" => 2}
	)

	activity = insert(:note_activity, data: %{"actor" => user.ap_id})

	assert {:ok, updated_object} = Utils.remove_announce_from_object(activity, object)
	assert updated_object.data["announcements"] == [user2.ap_id]
	assert updated_object.data["announcement_count"] == 1
	end
	end

	describe "get_cached_emoji_reactions/1" do
	test "returns the data or an emtpy list" do
	object = insert(:note)
	assert Utils.get_cached_emoji_reactions(object) == []

	object = insert(:note, data: %{"reactions" => [["x", ["lain"]]]})
	assert Utils.get_cached_emoji_reactions(object) == [["x", ["lain"]]]

	object = insert(:note, data: %{"reactions" => %{}})
	assert Utils.get_cached_emoji_reactions(object) == []
	end
	end

	describe "parse_json_ld_context/1" do
	test "it expands IRI schemes" do
	object = %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"https://w3id.org/security/v1",
	%{
	"manuallyApprovesFollowers" => "as:manuallyApprovesFollowers",
	"toot" => "http://joinmastodon.org/ns#",
	"featured" => %{"@id" => "toot:featured", "@type" => "@id"},
	"schema" => "http://schema.org#",
	"PropertyValue" => "schema:PropertyValue",
	"misskey" => "https://misskey-hub.net/ns#",
	"isCat" => "misskey:isCat"
	}
	]
	}

	assert Utils.parse_json_ld_context(object) == %{
	- "as:manuallyApprovesFollowers" => ["manuallyApprovesFollowers", "as:manuallyApprovesFollowers"],
	+ "as:manuallyApprovesFollowers" => [
	+ "manuallyApprovesFollowers",
	+ "as:manuallyApprovesFollowers"
	+ ],
	"http://joinmastodon.org/ns#" => ["toot", "http://joinmastodon.org/ns#"],
	- "http://joinmastodon.org/ns#featured" => ["featured", "http://joinmastodon.org/ns#featured", "toot:featured"],
	+ "http://joinmastodon.org/ns#featured" => [
	+ "featured",
	+ "http://joinmastodon.org/ns#featured",
	+ "toot:featured"
	+ ],
	"http://schema.org#" => ["schema", "http://schema.org#"],
	- "http://schema.org#PropertyValue" => ["PropertyValue", "http://schema.org#PropertyValue", "schema:PropertyValue"],
	+ "http://schema.org#PropertyValue" => [
	+ "PropertyValue",
	+ "http://schema.org#PropertyValue",
	+ "schema:PropertyValue"
	+ ],
	"https://misskey-hub.net/ns#" => ["misskey", "https://misskey-hub.net/ns#"],
	- "https://misskey-hub.net/ns#isCat" => ["isCat", "https://misskey-hub.net/ns#isCat", "misskey:isCat"]
	+ "https://misskey-hub.net/ns#isCat" => [
	+ "isCat",
	+ "https://misskey-hub.net/ns#isCat",
	+ "misskey:isCat"
	+ ]
	}
	end
	end

	describe "lookup_json_ld_key/3" do
	test "it gets the correct value" do
	object = %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"https://w3id.org/security/v1",
	%{
	"manuallyApprovesFollowers" => "as:manuallyApprovesFollowers",
	"toot" => "http://joinmastodon.org/ns#",
	"featured" => %{"@id" => "toot:featured", "@type" => "@id"},
	"schema" => "http://schema.org#",
	"PropertyValue" => "schema:PropertyValue",
	"misskey" => "https://misskey-hub.net/ns#",
	"isCat" => "misskey:isCat"
	}
	],
	"featured" => "https://example.com/featured",
	"isCat" => true
	}

	context = Utils.parse_json_ld_context(object)

	assert {:ok, "https://example.com/featured"} =
	Utils.lookup_json_ld_key(object, context, "http://joinmastodon.org/ns#featured")

	assert {:ok, true} =
	Utils.lookup_json_ld_key(object, context, "https://misskey-hub.net/ns#isCat")

	assert {:not_found, nil} =
	Utils.lookup_json_ld_key(object, context, "https://misskey-hub.net/ns#random")

	assert {:not_found, nil} =
	Utils.lookup_json_ld_key(object, context, "http://schema.org#PropertyValue")
	end

	test "it works with alternate property names" do
	object = %{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"https://w3id.org/security/v1",
	%{
	"toot" => "http://joinmastodon.org/ns#",
	- "featured" => %{"@id" => "toot:featured", "@type" => "@id"},
	+ "featured" => %{"@id" => "toot:featured", "@type" => "@id"}
	}
	]
	}

	context = Utils.parse_json_ld_context(object)

	assert {:ok, "https://example.com/featured"} =
	- Utils.lookup_json_ld_key(%{"featured" => "https://example.com/featured"}, context, "http://joinmastodon.org/ns#featured")
	+ Utils.lookup_json_ld_key(
	+ %{"featured" => "https://example.com/featured"},
	+ context,
	+ "http://joinmastodon.org/ns#featured"
	+ )

	assert {:ok, "https://example.com/featured"} =
	- Utils.lookup_json_ld_key(%{"toot:featured" => "https://example.com/featured"}, context, "http://joinmastodon.org/ns#featured")
	+ Utils.lookup_json_ld_key(
	+ %{"toot:featured" => "https://example.com/featured"},
	+ context,
	+ "http://joinmastodon.org/ns#featured"
	+ )

	assert {:ok, "https://example.com/featured"} =
	- Utils.lookup_json_ld_key(%{"http://joinmastodon.org/ns#featured" => "https://example.com/featured"}, context, "http://joinmastodon.org/ns#featured")
	+ Utils.lookup_json_ld_key(
	+ %{"http://joinmastodon.org/ns#featured" => "https://example.com/featured"},
	+ context,
	+ "http://joinmastodon.org/ns#featured"
	+ )
	end

	test "it works with full names and do not need a context" do
	object = %{
	"@context" => []
	}

	context = Utils.parse_json_ld_context(object)

	assert {:ok, "https://example.com/featured"} =
	- Utils.lookup_json_ld_key(%{"http://joinmastodon.org/ns#featured" => "https://example.com/featured"}, context, "http://joinmastodon.org/ns#featured")
	+ Utils.lookup_json_ld_key(
	+ %{"http://joinmastodon.org/ns#featured" => "https://example.com/featured"},
	+ context,
	+ "http://joinmastodon.org/ns#featured"
	+ )
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jul 19, 10:00 AM (1 d, 21 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1695237
Default Alt Text: (55 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions