No OneTemporary
Actions

Authored By

Unknown

Size

33 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/object_validator.ex b/lib/pleroma/web/activity_pub/object_validator.ex
	index 4ef036f34..61d896a5b 100644
	--- a/lib/pleroma/web/activity_pub/object_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validator.ex
	@@ -1,335 +1,340 @@
	# 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.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.
	"""

	@behaviour Pleroma.Web.ActivityPub.ObjectValidator.Validating

	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.AcceptRejectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AddRemoveValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AnswerValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.AudioImageVideoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CreateGenericValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.EventValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator

	@impl true
	def validate(object, meta)

	def validate(%{"type" => "Block"} = block_activity, meta) do
	with {:ok, block_activity} <-
	block_activity
	\|> BlockValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	block_activity = stringify_keys(block_activity)
	outgoing_blocks = Pleroma.Config.get([:activitypub, :outgoing_blocks])

	meta =
	if !outgoing_blocks do
	Keyword.put(meta, :do_not_federate, true)
	else
	meta
	end

	{:ok, block_activity, meta}
	end
	end

	def validate(%{"type" => "Undo"} = object, meta) do
	with {:ok, object} <-
	object
	\|> UndoValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	undone_object = Activity.get_by_ap_id(object["object"])

	meta =
	meta
	\|> Keyword.put(:object_data, undone_object.data)

	{:ok, object, meta}
	end
	end

	def validate(%{"type" => "Delete"} = object, meta) do
	with cng <- DeleteValidator.cast_and_validate(object),
	do_not_federate <- DeleteValidator.do_not_federate?(cng),
	{:ok, object} <- Ecto.Changeset.apply_action(cng, :insert) do
	object = stringify_keys(object)
	meta = Keyword.put(meta, :do_not_federate, do_not_federate)
	{:ok, object, meta}
	end
	end

	def validate(
	%{"type" => "Create", "object" => %{"type" => "ChatMessage"} = 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
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(
	%{"type" => "Create", "object" => %{"type" => objtype} = object} = create_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Image Event Article Note Page] do
	with {:ok, object_data} <-
	- cast_and_apply_and_stringify_with_history(object, activity_data: create_activity),
	+ object
	+ \|> CommonFixes.maybe_add_language_from_activity(create_activity)
	+ \|> cast_and_apply_and_stringify_with_history(),
	meta = Keyword.put(meta, :object_data, object_data),
	{:ok, create_activity} <-
	create_activity
	\|> CreateGenericValidator.cast_and_validate(meta)
	\|> Ecto.Changeset.apply_action(:insert) do
	create_activity = stringify_keys(create_activity)
	{:ok, create_activity, meta}
	end
	end

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Event Question Audio Video Image Article Note Page] do
	validator =
	case type do
	"Event" -> EventValidator
	"Question" -> QuestionValidator
	"Audio" -> AudioImageVideoValidator
	"Video" -> AudioImageVideoValidator
	"Image" -> AudioImageVideoValidator
	"Article" -> ArticleNotePageValidator
	"Note" -> ArticleNotePageValidator
	"Page" -> ArticleNotePageValidator
	end

	with {:ok, object} <-
	do_separate_with_history(object, fn object ->
	with {:ok, object} <-
	object
	\|> validator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)

	# Insert copy of hashtags as strings for the non-hashtag table indexing
	tag = (object["tag"] \|\| []) ++ Object.hashtags(%Object{data: object})
	object = Map.put(object, "tag", tag)

	{:ok, object}
	end
	end) do
	{:ok, object, meta}
	end
	end

	def validate(
	%{"type" => "Update", "object" => %{"type" => objtype} = object} = update_activity,
	meta
	)
	when objtype in ~w[Question Answer Audio Video Event Article Note Page] do
	with {_, false} <- {:local, Access.get(meta, :local, false)},
	- {_, {:ok, object_data, _}} <- {:object_validation, validate(object, meta)},
	+ {_, {:ok, object_data, _}} <-
	+ {:object_validation,
	+ object
	+ \|> CommonFixes.maybe_add_language_from_activity(update_activity)
	+ \|> validate(meta)},
	meta = Keyword.put(meta, :object_data, object_data),
	{:ok, update_activity} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	update_activity = stringify_keys(update_activity)
	{:ok, update_activity, meta}
	else
	{:local, _} ->
	with {:ok, object} <-
	update_activity
	\|> UpdateValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end

	{:object_validation, e} ->
	e
	end
	end

	def validate(%{"type" => type} = object, meta)
	when type in ~w[Accept Reject Follow Update Like EmojiReact Announce
	ChatMessage Answer] do
	validator =
	case type do
	"Accept" -> AcceptRejectValidator
	"Reject" -> AcceptRejectValidator
	"Follow" -> FollowValidator
	"Update" -> UpdateValidator
	"Like" -> LikeValidator
	"EmojiReact" -> EmojiReactValidator
	"Announce" -> AnnounceValidator
	"ChatMessage" -> ChatMessageValidator
	"Answer" -> AnswerValidator
	end

	with {:ok, object} <-
	object
	\|> validator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(%{"type" => type} = object, meta) when type in ~w(Add Remove) do
	with {:ok, object} <-
	object
	\|> AddRemoveValidator.cast_and_validate()
	\|> Ecto.Changeset.apply_action(:insert) do
	object = stringify_keys(object)
	{:ok, object, meta}
	end
	end

	def validate(o, m), do: {:error, {:validator_not_set, {o, m}}}

	- def cast_and_apply_and_stringify_with_history(object, meta \\ []) do
	+ def cast_and_apply_and_stringify_with_history(object) do
	do_separate_with_history(object, fn object ->
	- with {:ok, object_data} <- cast_and_apply(object, meta),
	+ with {:ok, object_data} <- cast_and_apply(object),
	object_data <- object_data \|> stringify_keys() do
	{:ok, object_data}
	end
	end)
	end

	- def cast_and_apply(object, meta \\ [])
	-
	- def cast_and_apply(%{"type" => "ChatMessage"} = object, _) do
	+ def cast_and_apply(%{"type" => "ChatMessage"} = object) do
	ChatMessageValidator.cast_and_apply(object)
	end

	- def cast_and_apply(%{"type" => "Question"} = object, _) do
	+ def cast_and_apply(%{"type" => "Question"} = object) do
	QuestionValidator.cast_and_apply(object)
	end

	- def cast_and_apply(%{"type" => "Answer"} = object, _) do
	+ def cast_and_apply(%{"type" => "Answer"} = object) do
	AnswerValidator.cast_and_apply(object)
	end

	- def cast_and_apply(%{"type" => type} = object, _) when type in ~w[Audio Image Video] do
	+ def cast_and_apply(%{"type" => type} = object) when type in ~w[Audio Image Video] do
	AudioImageVideoValidator.cast_and_apply(object)
	end

	- def cast_and_apply(%{"type" => "Event"} = object, meta) do
	- EventValidator.cast_and_apply(object, meta)
	+ def cast_and_apply(%{"type" => "Event"} = object) do
	+ EventValidator.cast_and_apply(object)
	end

	- def cast_and_apply(%{"type" => type} = object, meta) when type in ~w[Article Note Page] do
	- ArticleNotePageValidator.cast_and_apply(object, meta)
	+ def cast_and_apply(%{"type" => type} = object) when type in ~w[Article Note Page] do
	+ ArticleNotePageValidator.cast_and_apply(object)
	end

	- def cast_and_apply(o, _), do: {:error, {:validator_not_set, o}}
	+ def cast_and_apply(o), do: {:error, {:validator_not_set, o}}

	def stringify_keys(object) when is_struct(object) do
	object
	\|> Map.from_struct()
	\|> stringify_keys
	end

	def stringify_keys(object) when is_map(object) do
	object
	\|> Enum.filter(fn {_, v} -> v != nil end)
	\|> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
	end

	def stringify_keys(object) when is_list(object) do
	object
	\|> Enum.map(&stringify_keys/1)
	end

	def stringify_keys(object), do: object

	def fetch_actor(object) do
	with actor <- Containment.get_actor(object),
	{:ok, actor} <- ObjectValidators.ObjectID.cast(actor) do
	User.get_or_fetch_by_ap_id(actor)
	end
	end

	def fetch_actor_and_object(object) do
	fetch_actor(object)
	Object.normalize(object["object"], fetch: true)
	:ok
	end

	defp for_each_history_item(
	%{"type" => "OrderedCollection", "orderedItems" => items} = history,
	object,
	fun
	) do
	processed_items =
	Enum.map(items, fn item ->
	with item <- Map.put(item, "id", object["id"]),
	{:ok, item} <- fun.(item) do
	item
	else
	_ -> nil
	end
	end)

	if Enum.all?(processed_items, &(not is_nil(&1))) do
	{:ok, Map.put(history, "orderedItems", processed_items)}
	else
	{:error, :invalid_history}
	end
	end

	defp for_each_history_item(nil, _object, _fun) do
	{:ok, nil}
	end

	defp for_each_history_item(_, _object, _fun) do
	{:error, :invalid_history}
	end

	# fun is (object -> {:ok, validated_object_with_string_keys})
	defp do_separate_with_history(object, fun) do
	with history <- object["formerRepresentations"],
	object <- Map.drop(object, ["formerRepresentations"]),
	{_, {:ok, object}} <- {:main_body, fun.(object)},
	{_, {:ok, history}} <- {:history_items, for_each_history_item(history, object, fun)} do
	object =
	if history do
	Map.put(object, "formerRepresentations", history)
	else
	object
	end

	{:ok, object}
	else
	{:main_body, e} -> e
	{:history_items, e} -> e
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex b/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	index 417f04312..4e27284aa 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	@@ -1,112 +1,112 @@
	# 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.ObjectValidators.ArticleNotePageValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	quote do
	unquote do
	import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	message_fields()
	object_fields()
	status_object_fields()
	end
	end

	field(:replies, {:array, ObjectValidators.ObjectID}, default: [])
	end

	- def cast_and_apply(data, meta \\ []) do
	+ def cast_and_apply(data) do
	data
	- \|> cast_data(meta)
	+ \|> cast_data()
	\|> apply_action(:insert)
	end

	- def cast_and_validate(data, meta \\ []) do
	+ def cast_and_validate(data) do
	data
	- \|> cast_data(meta)
	+ \|> cast_data()
	\|> validate_data()
	end

	- def cast_data(data, meta \\ []) do
	+ def cast_data(data) do
	%__MODULE__{}
	- \|> changeset(data, meta)
	+ \|> changeset(data)
	end

	defp fix_url(%{"url" => url} = data) when is_bitstring(url), do: data
	defp fix_url(%{"url" => url} = data) when is_map(url), do: Map.put(data, "url", url["href"])
	defp fix_url(data), do: data

	defp fix_tag(%{"tag" => tag} = data) when is_list(tag) do
	Map.put(data, "tag", Enum.filter(tag, &is_map/1))
	end

	defp fix_tag(%{"tag" => tag} = data) when is_map(tag), do: Map.put(data, "tag", [tag])
	defp fix_tag(data), do: Map.drop(data, ["tag"])

	defp fix_replies(%{"replies" => %{"first" => %{"items" => replies}}} = data)
	when is_list(replies),
	do: Map.put(data, "replies", replies)

	defp fix_replies(%{"replies" => %{"items" => replies}} = data) when is_list(replies),
	do: Map.put(data, "replies", replies)

	# TODO: Pleroma does not have any support for Collections at the moment.
	# If the `replies` field is not something the ObjectID validator can handle,
	# the activity/object would be rejected, which is bad behavior.
	defp fix_replies(%{"replies" => replies} = data) when not is_list(replies),
	do: Map.drop(data, ["replies"])

	defp fix_replies(data), do: data

	def fix_attachments(%{"attachment" => attachment} = data) when is_map(attachment),
	do: Map.put(data, "attachment", [attachment])

	def fix_attachments(data), do: data

	- defp fix(data, meta) do
	+ defp fix(data) do
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()
	\|> fix_url()
	\|> fix_tag()
	\|> fix_replies()
	\|> fix_attachments()
	\|> CommonFixes.fix_quote_url()
	\|> Transmogrifier.fix_emoji()
	\|> Transmogrifier.fix_content_map()
	- \|> CommonFixes.maybe_add_language(meta)
	+ \|> CommonFixes.maybe_add_language()
	\|> CommonFixes.maybe_add_content_map()
	end

	- def changeset(struct, data, meta \\ []) do
	- data = fix(data, meta)
	+ def changeset(struct, data) do
	+ data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:attachment, :tag])
	\|> cast_embed(:attachment)
	\|> cast_embed(:tag)
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Article", "Note", "Page"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex b/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	index 218342136..e732a6430 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/common_fixes.ex
	@@ -1,177 +1,186 @@
	# 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.ObjectValidators.CommonFixes do
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils

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

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

	require Pleroma.Constants

	def cast_and_filter_recipients(message, field, follower_collection, field_fallback \\ []) do
	{:ok, data} = ObjectValidators.Recipients.cast(message[field] \|\| field_fallback)

	data =
	Enum.reject(data, fn x ->
	String.ends_with?(x, "/followers") and x != follower_collection
	end)

	Map.put(message, field, data)
	end

	def fix_object_defaults(data) do
	context =
	Utils.maybe_create_context(
	data["context"] \|\| data["conversation"] \|\| data["inReplyTo"] \|\| data["id"]
	)

	%User{follower_address: follower_collection} = User.get_cached_by_ap_id(data["attributedTo"])

	data
	\|> Map.put("context", context)
	\|> cast_and_filter_recipients("to", follower_collection)
	\|> cast_and_filter_recipients("cc", follower_collection)
	\|> cast_and_filter_recipients("bto", follower_collection)
	\|> cast_and_filter_recipients("bcc", follower_collection)
	\|> Transmogrifier.fix_implicit_addressing(follower_collection)
	end

	def fix_activity_addressing(activity) do
	%User{follower_address: follower_collection} = User.get_cached_by_ap_id(activity["actor"])

	activity
	\|> cast_and_filter_recipients("to", follower_collection)
	\|> cast_and_filter_recipients("cc", follower_collection)
	\|> cast_and_filter_recipients("bto", follower_collection)
	\|> cast_and_filter_recipients("bcc", follower_collection)
	\|> Transmogrifier.fix_implicit_addressing(follower_collection)
	end

	def fix_actor(data) do
	actor =
	data
	\|> Map.put_new("actor", data["attributedTo"])
	\|> Containment.get_actor()

	data
	\|> Map.put("actor", actor)
	\|> Map.put("attributedTo", actor)
	end

	def fix_activity_context(data, %Object{data: %{"context" => object_context}}) do
	data
	\|> Map.put("context", object_context)
	end

	def fix_object_action_recipients(%{"actor" => actor} = data, %Object{data: %{"actor" => actor}}) do
	to = ((data["to"] \|\| []) -- [actor]) \|> Enum.uniq()

	Map.put(data, "to", to)
	end

	def fix_object_action_recipients(data, %Object{data: %{"actor" => actor}}) do
	to = ((data["to"] \|\| []) ++ [actor]) \|> Enum.uniq()

	Map.put(data, "to", to)
	end

	def fix_quote_url(%{"quoteUrl" => _quote_url} = data), do: data

	# Fedibird
	# https://github.com/fedibird/mastodon/commit/dbd7ae6cf58a92ec67c512296b4daaea0d01e6ac
	def fix_quote_url(%{"quoteUri" => quote_url} = data) do
	Map.put(data, "quoteUrl", quote_url)
	end

	# Old Fedibird (bug)
	# https://github.com/fedibird/mastodon/issues/9
	def fix_quote_url(%{"quoteURL" => quote_url} = data) do
	Map.put(data, "quoteUrl", quote_url)
	end

	# Misskey fallback
	def fix_quote_url(%{"_misskey_quote" => quote_url} = data) do
	Map.put(data, "quoteUrl", quote_url)
	end

	def fix_quote_url(%{"tag" => [_ \| _] = tags} = data) do
	tag = Enum.find(tags, &is_object_link_tag/1)

	if not is_nil(tag) do
	data
	\|> Map.put("quoteUrl", tag["href"])
	else
	data
	end
	end

	def fix_quote_url(data), do: data

	# https://codeberg.org/fediverse/fep/src/branch/main/fep/e232/fep-e232.md
	def is_object_link_tag(%{
	"type" => "Link",
	"mediaType" => media_type,
	"href" => href
	})
	when media_type in Pleroma.Constants.activity_json_mime_types() and is_binary(href) do
	true
	end

	def is_object_link_tag(_), do: false

	- def maybe_add_language(object, meta \\ []) do
	+ def maybe_add_language_from_activity(object, activity) do
	+ language = get_language_from_context(activity)
	+
	+ if language do
	+ Map.put(object, "language", language)
	+ else
	+ object
	+ end
	+ end
	+
	+ def maybe_add_language(object) do
	language =
	[
	get_language_from_context(object),
	- get_language_from_context(Keyword.get(meta, :activity_data)),
	get_language_from_content_map(object)
	]
	\|> Enum.find(&is_good_locale_code?(&1))

	if language do
	Map.put(object, "language", language)
	else
	object
	end
	end

	defp get_language_from_context(%{"@context" => context}) when is_list(context) do
	case context
	\|> Enum.find(fn
	%{"@language" => language} -> language != "und"
	_ -> nil
	end) do
	%{"@language" => language} -> language
	_ -> nil
	end
	end

	defp get_language_from_context(_), do: nil

	defp get_language_from_content_map(%{"contentMap" => content_map, "content" => source_content}) do
	content_groups = Map.to_list(content_map)

	case Enum.find(content_groups, fn {_, content} -> content == source_content end) do
	{language, _} -> language
	_ -> nil
	end
	end

	defp get_language_from_content_map(_), do: nil

	def maybe_add_content_map(%{"language" => language, "content" => content} = object)
	when not_empty_string(language) do
	Map.put(object, "contentMap", Map.put(%{}, language, content))
	end

	def maybe_add_content_map(object), do: object
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/event_validator.ex b/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	index 56ca6fe40..ec23770ad 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	@@ -1,73 +1,74 @@
	# 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.ObjectValidators.EventValidator do
	use Ecto.Schema

	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	# Extends from NoteValidator
	embedded_schema do
	quote do
	unquote do
	import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	message_fields()
	object_fields()
	status_object_fields()
	end
	end
	end

	- def cast_and_apply(data, meta \\ []) do
	+ def cast_and_apply(data) do
	data
	- \|> cast_data(meta)
	+ \|> cast_data()
	\|> apply_action(:insert)
	end

	- def cast_and_validate(data, meta \\ []) do
	+ def cast_and_validate(data) do
	data
	- \|> cast_data(meta)
	+ \|> cast_data()
	\|> validate_data()
	end

	- def cast_data(data, meta \\ []) do
	+ @spec cast_data(map()) :: map()
	+ def cast_data(data) do
	%__MODULE__{}
	- \|> changeset(data, meta)
	+ \|> changeset(data)
	end

	- defp fix(data, meta) do
	+ defp fix(data) do
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()
	\|> Transmogrifier.fix_emoji()
	- \|> CommonFixes.maybe_add_language(meta)
	+ \|> CommonFixes.maybe_add_language()
	\|> CommonFixes.maybe_add_content_map()
	end

	- def changeset(struct, data, meta \\ []) do
	- data = fix(data, meta)
	+ def changeset(struct, data) do
	+ data = fix(data)

	struct
	\|> cast(data, __schema__(:fields) -- [:attachment, :tag])
	\|> cast_embed(:attachment)
	\|> cast_embed(:tag)
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Event"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/test/pleroma/web/activity_pub/object_validators/article_note_page_validator_test.exs b/test/pleroma/web/activity_pub/object_validators/article_note_page_validator_test.exs
	index 25e29c878..611d0bcd0 100644
	--- a/test/pleroma/web/activity_pub/object_validators/article_note_page_validator_test.exs
	+++ b/test/pleroma/web/activity_pub/object_validators/article_note_page_validator_test.exs
	@@ -1,238 +1,235 @@
	# 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.ObjectValidators.ArticleNotePageValidatorTest do
	use Pleroma.DataCase, async: true

	alias Pleroma.Web.ActivityPub.ObjectValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNotePageValidator
	alias Pleroma.Web.ActivityPub.Utils

	import Pleroma.Factory

	describe "Notes" do
	setup do
	user = insert(:user)

	note = %{
	"id" => Utils.generate_activity_id(),
	"type" => "Note",
	"actor" => user.ap_id,
	"to" => [user.follower_address],
	"cc" => [],
	"content" => "Hellow this is content.",
	"context" => "xxx",
	"summary" => "a post"
	}

	%{user: user, note: note}
	end

	test "a basic note validates", %{note: note} do
	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note)
	end

	test "a note from factory validates" do
	note = insert(:note)
	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note.data)
	end
	end

	describe "Note with history" do
	setup do
	user = insert(:user)
	{:ok, activity} = Pleroma.Web.CommonAPI.post(user, %{status: "mew mew :dinosaur:"})
	{:ok, edit} = Pleroma.Web.CommonAPI.update(user, activity, %{status: "edited :blank:"})

	{:ok, %{"object" => external_rep}} =
	Pleroma.Web.ActivityPub.Transmogrifier.prepare_outgoing(edit.data)

	%{external_rep: external_rep}
	end

	test "edited note", %{external_rep: external_rep} do
	assert %{"formerRepresentations" => %{"orderedItems" => [%{"tag" => [_]}]}} = external_rep

	{:ok, validate_res, []} = ObjectValidator.validate(external_rep, [])

	assert %{"formerRepresentations" => %{"orderedItems" => [%{"emoji" => %{"dinosaur" => _}}]}} =
	validate_res
	end

	test "edited note, badly-formed formerRepresentations", %{external_rep: external_rep} do
	external_rep = Map.put(external_rep, "formerRepresentations", %{})

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

	test "edited note, badly-formed history item", %{external_rep: external_rep} do
	history_item =
	Enum.at(external_rep["formerRepresentations"]["orderedItems"], 0)
	\|> Map.put("type", "Foo")

	external_rep =
	put_in(
	external_rep,
	["formerRepresentations", "orderedItems"],
	[history_item]
	)

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

	test "a Note from Roadhouse validates" do
	insert(:user, ap_id: "https://macgirvin.com/channel/mike")

	%{"object" => note} =
	"test/fixtures/roadhouse-create-activity.json"
	\|> File.read!()
	\|> Jason.decode!()

	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note)
	end

	test "a note with an attachment should work", _ do
	insert(:user, %{ap_id: "https://owncast.localhost.localdomain/federation/user/streamer"})

	note =
	"test/fixtures/owncast-note-with-attachment.json"
	\|> File.read!()
	\|> Jason.decode!()

	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note)
	end

	test "a Note without replies/first/items validates" do
	insert(:user, ap_id: "https://mastodon.social/users/emelie")

	note =
	"test/fixtures/tesla_mock/status.emelie.json"
	\|> File.read!()
	\|> Jason.decode!()
	\|> pop_in(["replies", "first", "items"])
	\|> elem(1)

	%{valid?: true} = ArticleNotePageValidator.cast_and_validate(note)
	end

	test "Fedibird quote post" do
	insert(:user, ap_id: "https://fedibird.com/users/noellabo")

	data = File.read!("test/fixtures/quote_post/fedibird_quote_post.json") \|> Jason.decode!()
	cng = ArticleNotePageValidator.cast_and_validate(data)

	assert cng.valid?
	assert cng.changes.quoteUrl == "https://misskey.io/notes/8vsn2izjwh"
	end

	test "Fedibird quote post with quoteUri field" do
	insert(:user, ap_id: "https://fedibird.com/users/noellabo")

	data = File.read!("test/fixtures/quote_post/fedibird_quote_uri.json") \|> Jason.decode!()
	cng = ArticleNotePageValidator.cast_and_validate(data)

	assert cng.valid?
	assert cng.changes.quoteUrl == "https://fedibird.com/users/yamako/statuses/107699333438289729"
	end

	test "Misskey quote post" do
	insert(:user, ap_id: "https://misskey.io/users/7rkrarq81i")

	data = File.read!("test/fixtures/quote_post/misskey_quote_post.json") \|> Jason.decode!()
	cng = ArticleNotePageValidator.cast_and_validate(data)

	assert cng.valid?
	assert cng.changes.quoteUrl == "https://misskey.io/notes/8vs6wxufd0"
	end

	test "Parse tag as quote" do
	# https://codeberg.org/fediverse/fep/src/branch/main/fep/e232/fep-e232.md

	insert(:user, ap_id: "https://server.example/users/1")

	data = File.read!("test/fixtures/quote_post/fep-e232-tag-example.json") \|> Jason.decode!()
	cng = ArticleNotePageValidator.cast_and_validate(data)

	assert cng.valid?
	assert cng.changes.quoteUrl == "https://server.example/objects/123"

	assert Enum.at(cng.changes.tag, 0).changes == %{
	type: "Link",
	mediaType: "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	href: "https://server.example/objects/123",
	name: "RE: https://server.example/objects/123"
	}
	end

	describe "Note language" do
	test "it detects language from JSON-LD context" do
	user = insert(:user)

	note_activity = %{
	"@context" => ["https://www.w3.org/ns/activitystreams", %{"@language" => "pl"}],
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "Szczęść Boże",
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

	- {:ok, object} =
	- ArticleNotePageValidator.cast_and_apply(note_activity["object"],
	- activity_data: note_activity
	- )
	+ {:ok, _create_activity, meta} = ObjectValidator.validate(note_activity, []) \|> IO.inspect()

	- assert object.language == "pl"
	+ assert meta[:object_data]["language"] == "pl"
	end

	test "it detects language from contentMap" do
	user = insert(:user)

	note = %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "Szczęść Boże",
	"contentMap" => %{
	"de" => "Gott segne",
	"pl" => "Szczęść Boże"
	},
	"attributedTo" => user.ap_id
	}

	{:ok, object} = ArticleNotePageValidator.cast_and_apply(note)

	assert object.language == "pl"
	end

	test "it adds contentMap if language is specified" do
	user = insert(:user)

	note = %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"id" => Utils.generate_object_id(),
	"type" => "Note",
	"content" => "тест",
	"language" => "uk",
	"attributedTo" => user.ap_id
	}

	{:ok, object} = ArticleNotePageValidator.cast_and_apply(note)

	assert object.contentMap == %{
	"uk" => "тест"
	}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 29, 7:01 PM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1798161
Default Alt Text: (33 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions