No OneTemporary
Actions

Authored By

Unknown

Size

61 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/activity_pub/object_validators/accept_reject_validator.ex b/lib/pleroma/web/activity_pub/object_validators/accept_reject_validator.ex
	index b577a1044..7c3c8d0fa 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/accept_reject_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/accept_reject_validator.ex
	@@ -1,56 +1,56 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AcceptRejectValidator do
	use Ecto.Schema

	alias Pleroma.Activity
	- alias Pleroma.EctoType.ActivityPub.ObjectValidators

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	- field(:object, ObjectValidators.ObjectID)
	- field(:actor, ObjectValidators.ObjectID)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	defp validate_data(cng) do
	cng
	\|> validate_required([:id, :type, :actor, :to, :cc, :object])
	\|> validate_inclusion(:type, ["Accept", "Reject"])
	\|> validate_actor_presence()
	\|> validate_object_presence(allowed_types: ["Follow"])
	\|> validate_accept_reject_rights()
	end

	def cast_and_validate(data) do
	data
	\|> cast_data
	\|> validate_data
	end

	def validate_accept_reject_rights(cng) do
	with object_id when is_binary(object_id) <- get_field(cng, :object),
	%Activity{data: %{"object" => followed_actor}} <- Activity.get_by_ap_id(object_id),
	true <- followed_actor == get_field(cng, :actor) do
	cng
	else
	_e ->
	cng
	\|> add_error(:actor, "can't accept or reject the given activity")
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/add_remove_validator.ex b/lib/pleroma/web/activity_pub/object_validators/add_remove_validator.ex
	index f885aabe4..fc482c9c0 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/add_remove_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/add_remove_validator.ex
	@@ -1,77 +1,78 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AddRemoveValidator do
	use Ecto.Schema

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	require Pleroma.Constants

	- alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.User

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	field(:target)
	- field(:object, ObjectValidators.ObjectID)
	- field(:actor, ObjectValidators.ObjectID)
	- field(:type)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	+
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	end

	def cast_and_validate(data) do
	{:ok, actor} = User.get_or_fetch_by_ap_id(data["actor"])

	{:ok, actor} = maybe_refetch_user(actor)

	data
	\|> maybe_fix_data_for_mastodon(actor)
	\|> cast_data()
	\|> validate_data(actor)
	end

	defp maybe_fix_data_for_mastodon(data, actor) do
	# Mastodon sends pin/unpin objects without id, to, cc fields
	data
	\|> Map.put_new("id", Pleroma.Web.ActivityPub.Utils.generate_activity_id())
	\|> Map.put_new("to", [Pleroma.Constants.as_public()])
	\|> Map.put_new("cc", [actor.follower_address])
	end

	defp cast_data(data) do
	cast(%__MODULE__{}, data, __schema__(:fields))
	end

	defp validate_data(changeset, actor) do
	changeset
	\|> validate_required([:id, :target, :object, :actor, :type, :to, :cc])
	\|> validate_inclusion(:type, ~w(Add Remove))
	\|> validate_actor_presence()
	\|> validate_collection_belongs_to_actor(actor)
	\|> validate_object_presence()
	end

	defp validate_collection_belongs_to_actor(changeset, actor) do
	validate_change(changeset, :target, fn :target, target ->
	if target == actor.featured_address do
	[]
	else
	[target: "collection doesn't belong to actor"]
	end
	end)
	end

	defp maybe_refetch_user(%User{featured_address: address} = user) when is_binary(address) do
	{:ok, user}
	end

	defp maybe_refetch_user(%User{ap_id: ap_id}) do
	Pleroma.Web.ActivityPub.Transmogrifier.upgrade_user_from_ap_id(ap_id)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex b/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	index 4db76f387..a7f2f6673 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/announce_validator.ex
	@@ -1,121 +1,123 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	require Pleroma.Constants

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	- field(:object, ObjectValidators.ObjectID)
	- field(:actor, ObjectValidators.ObjectID)
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	+
	field(:context, :string)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	field(:published, ObjectValidators.DateTime)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	data =
	data
	\|> fix()

	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	end

	defp fix(data) do
	data =
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_activity_addressing()

	with %Object{} = object <- Object.normalize(data["object"]) do
	data
	\|> CommonFixes.fix_activity_context(object)
	\|> CommonFixes.fix_object_action_recipients(object)
	else
	_ -> data
	end
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Announce"])
	\|> validate_required([:id, :type, :object, :actor, :to, :cc])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_existing_announce()
	\|> validate_announcable()
	end

	defp validate_announcable(cng) do
	with actor when is_binary(actor) <- get_field(cng, :actor),
	object when is_binary(object) <- get_field(cng, :object),
	%User{} = actor <- User.get_cached_by_ap_id(actor),
	%Object{} = object <- Object.get_cached_by_ap_id(object),
	false <- Visibility.is_public?(object) do
	same_actor = object.data["actor"] == actor.ap_id
	recipients = get_field(cng, :to) ++ get_field(cng, :cc)
	local_public = Utils.as_local_public()

	is_public =
	Enum.member?(recipients, Pleroma.Constants.as_public()) or
	Enum.member?(recipients, local_public)

	cond do
	same_actor && is_public ->
	cng
	\|> add_error(:actor, "can not announce this object publicly")

	!same_actor ->
	cng
	\|> add_error(:actor, "can not announce this object")

	true ->
	cng
	end
	else
	_ -> cng
	end
	end

	defp validate_existing_announce(cng) do
	actor = get_field(cng, :actor)
	object = get_field(cng, :object)

	if actor && object && Utils.get_existing_announce(actor, %{data: %{"id" => object}}) do
	cng
	\|> add_error(:actor, "already announced this object")
	\|> add_error(:object, "already announced by this actor")
	else
	cng
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/answer_validator.ex b/lib/pleroma/web/activity_pub/object_validators/answer_validator.ex
	index 3451e1ff8..4325e44f7 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/answer_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/answer_validator.ex
	@@ -1,69 +1,70 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AnswerValidator do
	use Ecto.Schema

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

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	- field(:bto, ObjectValidators.Recipients, default: [])
	- field(:bcc, ObjectValidators.Recipients, default: [])
	- field(:type, :string)
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ end
	+ end
	+
	field(:name, :string)
	field(:inReplyTo, ObjectValidators.ObjectID)
	field(:attributedTo, ObjectValidators.ObjectID)
	field(:context, :string)

	# TODO: Remove actor on objects
	field(:actor, ObjectValidators.ObjectID)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data()
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	data =
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()

	struct
	\|> cast(data, __schema__(:fields))
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Answer"])
	\|> validate_required([:id, :inReplyTo, :name, :attributedTo, :actor])
	\|> 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/article_note_page_validator.ex b/lib/pleroma/web/activity_pub/object_validators/article_note_page_validator.ex
	index 0d987116c..0aa249c4c 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,123 +1,97 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 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.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	- alias Pleroma.Web.ActivityPub.ObjectValidators.TagValidator
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	- field(:bto, ObjectValidators.Recipients, default: [])
	- field(:bcc, ObjectValidators.Recipients, default: [])
	- embeds_many(:tag, TagValidator)
	- field(:type, :string)
	-
	- field(:name, :string)
	- field(:summary, :string)
	- field(:content, :string)
	-
	- field(:context, :string)
	- # short identifier for PleromaFE to group statuses by context
	- field(:context_id, :integer)
	-
	- # TODO: Remove actor on objects
	- field(:actor, ObjectValidators.ObjectID)
	-
	- field(:attributedTo, ObjectValidators.ObjectID)
	- field(:published, ObjectValidators.DateTime)
	- field(:emoji, ObjectValidators.Emoji, default: %{})
	- field(:sensitive, :boolean, default: false)
	- embeds_many(:attachment, AttachmentValidator)
	- field(:replies_count, :integer, default: 0)
	- field(:like_count, :integer, default: 0)
	- field(:announcement_count, :integer, default: 0)
	- field(:inReplyTo, ObjectValidators.ObjectID)
	- field(:url, ObjectValidators.Uri)
	-
	- field(:likes, {:array, ObjectValidators.ObjectID}, default: [])
	- field(:announcements, {:array, ObjectValidators.ObjectID}, default: [])
	+ 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) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> 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: data
	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)

	defp fix_replies(%{"replies" => replies} = data) when is_bitstring(replies),
	do: Map.drop(data, ["replies"])

	defp fix_replies(data), do: data

	defp fix(data) do
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()
	\|> fix_url()
	\|> fix_tag()
	\|> fix_replies()
	\|> Transmogrifier.fix_emoji()
	\|> Transmogrifier.fix_content_map()
	end

	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, :context_id])
	\|> 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/audio_video_validator.ex b/lib/pleroma/web/activity_pub/object_validators/audio_video_validator.ex
	index 572687deb..331ec9050 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/audio_video_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/audio_video_validator.ex
	@@ -1,147 +1,120 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.AudioVideoValidator do
	use Ecto.Schema

	- alias Pleroma.EctoType.ActivityPub.ObjectValidators
	- alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	- alias Pleroma.Web.ActivityPub.ObjectValidators.TagValidator
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	- field(:bto, ObjectValidators.Recipients, default: [])
	- field(:bcc, ObjectValidators.Recipients, default: [])
	- embeds_many(:tag, TagValidator)
	- field(:type, :string)
	-
	- field(:name, :string)
	- field(:summary, :string)
	- field(:content, :string)
	-
	- field(:context, :string)
	- # short identifier for PleromaFE to group statuses by context
	- field(:context_id, :integer)
	-
	- # TODO: Remove actor on objects
	- field(:actor, ObjectValidators.ObjectID)
	-
	- field(:attributedTo, ObjectValidators.ObjectID)
	- field(:published, ObjectValidators.DateTime)
	- field(:emoji, ObjectValidators.Emoji, default: %{})
	- field(:sensitive, :boolean, default: false)
	- embeds_many(:attachment, AttachmentValidator)
	- field(:replies_count, :integer, default: 0)
	- field(:like_count, :integer, default: 0)
	- field(:announcement_count, :integer, default: 0)
	- field(:inReplyTo, ObjectValidators.ObjectID)
	- field(:url, ObjectValidators.Uri)
	-
	- field(:likes, {:array, ObjectValidators.ObjectID}, default: [])
	- field(:announcements, {:array, ObjectValidators.ObjectID}, default: [])
	+ 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) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp find_attachment(url) do
	mpeg_url =
	Enum.find(url, fn
	%{"mediaType" => mime_type, "tag" => tags} when is_list(tags) ->
	mime_type == "application/x-mpegURL"

	_ ->
	false
	end)

	url
	\|> Enum.concat(mpeg_url["tag"] \|\| [])
	\|> Enum.find(fn
	%{"mediaType" => mime_type} -> String.starts_with?(mime_type, ["video/", "audio/"])
	%{"mimeType" => mime_type} -> String.starts_with?(mime_type, ["video/", "audio/"])
	_ -> false
	end)
	end

	defp fix_url(%{"url" => url} = data) when is_list(url) do
	attachment = find_attachment(url)

	link_element =
	Enum.find(url, fn
	%{"mediaType" => "text/html"} -> true
	%{"mimeType" => "text/html"} -> true
	_ -> false
	end)

	data
	\|> Map.put("attachment", [attachment])
	\|> Map.put("url", link_element["href"])
	end

	defp fix_url(data), do: data

	defp fix_content(%{"mediaType" => "text/markdown", "content" => content} = data)
	when is_binary(content) do
	content =
	content
	\|> Pleroma.Formatter.markdown_to_html()
	\|> Pleroma.HTML.filter_tags()

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

	defp fix_content(data), do: data

	defp fix(data) do
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()
	\|> Transmogrifier.fix_emoji()
	\|> fix_url()
	\|> fix_content()
	end

	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, ["Audio", "Video"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context, :attachment])
	\|> 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/block_validator.ex b/lib/pleroma/web/activity_pub/object_validators/block_validator.ex
	index 88948135f..400e5e278 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/block_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/block_validator.ex
	@@ -1,42 +1,43 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator do
	use Ecto.Schema

	- alias Pleroma.EctoType.ActivityPub.ObjectValidators
	+ alias Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	import Ecto.Changeset
	- import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false
	+ @derive Jason.Encoder

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	- field(:actor, ObjectValidators.ObjectID)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	- field(:object, ObjectValidators.ObjectID)
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	defp validate_data(cng) do
	cng
	\|> validate_required([:id, :type, :actor, :to, :cc, :object])
	\|> validate_inclusion(:type, ["Block"])
	- \|> validate_actor_presence()
	- \|> validate_actor_presence(field_name: :object)
	+ \|> CommonValidations.validate_actor_presence()
	+ \|> CommonValidations.validate_actor_presence(field_name: :object)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data
	\|> validate_data
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/common_fields.ex b/lib/pleroma/web/activity_pub/object_validators/common_fields.ex
	new file mode 100644
	index 000000000..872f80ec3
	--- /dev/null
	+++ b/lib/pleroma/web/activity_pub/object_validators/common_fields.ex
	@@ -0,0 +1,68 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.ActivityPub.ObjectValidators.CommonFields do
	+ alias Pleroma.EctoType.ActivityPub.ObjectValidators
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	+ alias Pleroma.Web.ActivityPub.ObjectValidators.TagValidator
	+
	+ # Activities and Objects, except (Create)ChatMessage
	+ defmacro message_fields do
	+ quote bind_quoted: binding() do
	+ field(:type, :string)
	+ field(:id, ObjectValidators.ObjectID, primary_key: true)
	+
	+ field(:to, ObjectValidators.Recipients, default: [])
	+ field(:cc, ObjectValidators.Recipients, default: [])
	+ field(:bto, ObjectValidators.Recipients, default: [])
	+ field(:bcc, ObjectValidators.Recipients, default: [])
	+ end
	+ end
	+
	+ defmacro activity_fields do
	+ quote bind_quoted: binding() do
	+ field(:object, ObjectValidators.ObjectID)
	+ field(:actor, ObjectValidators.ObjectID)
	+ end
	+ end
	+
	+ # All objects except Answer and CHatMessage
	+ defmacro object_fields do
	+ quote bind_quoted: binding() do
	+ field(:content, :string)
	+
	+ field(:published, ObjectValidators.DateTime)
	+ field(:emoji, ObjectValidators.Emoji, default: %{})
	+ embeds_many(:attachment, AttachmentValidator)
	+ end
	+ end
	+
	+ # Basically objects that aren't ChatMessage and Answer
	+ defmacro status_object_fields do
	+ quote bind_quoted: binding() do
	+ # TODO: Remove actor on objects
	+ field(:actor, ObjectValidators.ObjectID)
	+ field(:attributedTo, ObjectValidators.ObjectID)
	+
	+ embeds_many(:tag, TagValidator)
	+
	+ field(:name, :string)
	+ field(:summary, :string)
	+
	+ field(:context, :string)
	+ # short identifier for PleromaFE to group statuses by context
	+ field(:context_id, :integer)
	+
	+ field(:sensitive, :boolean, default: false)
	+ field(:replies_count, :integer, default: 0)
	+ field(:like_count, :integer, default: 0)
	+ field(:announcement_count, :integer, default: 0)
	+ field(:inReplyTo, ObjectValidators.ObjectID)
	+ field(:url, ObjectValidators.Uri)
	+
	+ field(:likes, {:array, ObjectValidators.ObjectID}, default: [])
	+ field(:announcements, {:array, ObjectValidators.ObjectID}, default: [])
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/create_chat_message_validator.ex b/lib/pleroma/web/activity_pub/object_validators/create_chat_message_validator.ex
	index 7a31a99bf..6551f64ca 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/create_chat_message_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/create_chat_message_validator.ex
	@@ -1,91 +1,96 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	# NOTES
	# - Can probably be a generic create validator
	# - doesn't embed, will only get the object id
	defmodule Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator do
	use Ecto.Schema
	alias Pleroma.EctoType.ActivityPub.ObjectValidators

	alias Pleroma.Object

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ activity_fields()
	+ end
	+ end
	+
	field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:actor, ObjectValidators.ObjectID)
	field(:type, :string)
	field(:to, ObjectValidators.Recipients, default: [])
	- field(:object, ObjectValidators.ObjectID)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_data(data) do
	cast(%__MODULE__{}, data, __schema__(:fields))
	end

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

	defp validate_data(cng, meta) do
	cng
	\|> validate_required([:id, :actor, :to, :type, :object])
	\|> validate_inclusion(:type, ["Create"])
	\|> validate_actor_presence()
	\|> validate_recipients_match(meta)
	\|> validate_actors_match(meta)
	\|> validate_object_nonexistence()
	end

	def validate_object_nonexistence(cng) do
	cng
	\|> validate_change(:object, fn :object, object_id ->
	if Object.get_cached_by_ap_id(object_id) do
	[{:object, "The object to create already exists"}]
	else
	[]
	end
	end)
	end

	def validate_actors_match(cng, meta) do
	object_actor = meta[:object_data]["actor"]

	cng
	\|> validate_change(:actor, fn :actor, actor ->
	if actor == object_actor do
	[]
	else
	[{:actor, "Actor doesn't match with object actor"}]
	end
	end)
	end

	def validate_recipients_match(cng, meta) do
	object_recipients = meta[:object_data]["to"] \|\| []

	cng
	\|> validate_change(:to, fn :to, recipients ->
	activity_set = MapSet.new(recipients)
	object_set = MapSet.new(object_recipients)

	if MapSet.equal?(activity_set, object_set) do
	[]
	else
	[{:to, "Recipients don't match with object recipients"}]
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/create_generic_validator.ex b/lib/pleroma/web/activity_pub/object_validators/create_generic_validator.ex
	index d2de53049..803b5d5a1 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/create_generic_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/create_generic_validator.ex
	@@ -1,161 +1,161 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	# Code based on CreateChatMessageValidator
	# NOTES
	# - doesn't embed, will only get the object id
	defmodule Pleroma.Web.ActivityPub.ObjectValidators.CreateGenericValidator do
	use Ecto.Schema

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

	import Ecto.Changeset

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:actor, ObjectValidators.ObjectID)
	- field(:type, :string)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	- field(:bto, ObjectValidators.Recipients, default: [])
	- field(:bcc, ObjectValidators.Recipients, default: [])
	- field(:object, ObjectValidators.ObjectID)
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	+
	field(:expires_at, ObjectValidators.DateTime)

	# Should be moved to object, done for CommonAPI.Utils.make_context
	field(:context, :string)
	end

	def cast_data(data, meta \\ []) do
	data = fix(data, meta)

	%__MODULE__{}
	\|> changeset(data)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

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

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	end

	# CommonFixes.fix_activity_addressing adapted for Create specific behavior
	defp fix_addressing(data, object) do
	%User{follower_address: follower_collection} = User.get_cached_by_ap_id(data["actor"])

	data
	\|> CommonFixes.cast_and_filter_recipients("to", follower_collection, object["to"])
	\|> CommonFixes.cast_and_filter_recipients("cc", follower_collection, object["cc"])
	\|> CommonFixes.cast_and_filter_recipients("bto", follower_collection, object["bto"])
	\|> CommonFixes.cast_and_filter_recipients("bcc", follower_collection, object["bcc"])
	\|> Transmogrifier.fix_implicit_addressing(follower_collection)
	end

	def fix(data, meta) do
	object = meta[:object_data]

	data
	\|> CommonFixes.fix_actor()
	\|> Map.put_new("context", object["context"])
	\|> fix_addressing(object)
	end

	defp validate_data(cng, meta) do
	object = meta[:object_data]

	cng
	\|> validate_required([:actor, :type, :object, :to, :cc])
	\|> validate_inclusion(:type, ["Create"])
	\|> CommonValidations.validate_actor_presence()
	\|> validate_actors_match(object)
	\|> validate_context_match(object)
	\|> validate_addressing_match(object)
	\|> validate_object_nonexistence()
	\|> validate_object_containment()
	end

	def validate_object_containment(cng) do
	actor = get_field(cng, :actor)

	cng
	\|> validate_change(:object, fn :object, object_id ->
	%URI{host: object_id_host} = URI.parse(object_id)
	%URI{host: actor_host} = URI.parse(actor)

	if object_id_host == actor_host do
	[]
	else
	[{:object, "The host of the object id doesn't match with the host of the actor"}]
	end
	end)
	end

	def validate_object_nonexistence(cng) do
	cng
	\|> validate_change(:object, fn :object, object_id ->
	if Object.get_cached_by_ap_id(object_id) do
	[{:object, "The object to create already exists"}]
	else
	[]
	end
	end)
	end

	def validate_actors_match(cng, object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]

	cng
	\|> validate_change(:actor, fn :actor, actor ->
	if actor == attributed_to do
	[]
	else
	[{:actor, "Actor doesn't match with object attributedTo"}]
	end
	end)
	end

	def validate_context_match(cng, %{"context" => object_context}) do
	cng
	\|> validate_change(:context, fn :context, context ->
	if context == object_context do
	[]
	else
	[{:context, "context field not matching between Create and object (#{object_context})"}]
	end
	end)
	end

	def validate_addressing_match(cng, object) do
	[:to, :cc, :bcc, :bto]
	\|> Enum.reduce(cng, fn field, cng ->
	object_data = object[to_string(field)]

	validate_change(cng, field, fn field, data ->
	if data == object_data do
	[]
	else
	[{field, "field doesn't match with object (#{inspect(object_data)})"}]
	end
	end)
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/delete_validator.ex b/lib/pleroma/web/activity_pub/object_validators/delete_validator.ex
	index 05f93da82..f0c99356e 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/delete_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/delete_validator.ex
	@@ -1,85 +1,87 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.User

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	- field(:actor, ObjectValidators.ObjectID)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	+
	field(:deleted_activity_id, ObjectValidators.ObjectID)
	- field(:object, ObjectValidators.ObjectID)
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	def add_deleted_activity_id(cng) do
	object =
	cng
	\|> get_field(:object)

	with %Activity{id: id} <- Activity.get_create_by_object_ap_id(object) do
	cng
	\|> put_change(:deleted_activity_id, id)
	else
	_ -> cng
	end
	end

	@deletable_types ~w{
	Answer
	Article
	Audio
	ChatMessage
	Event
	Note
	Page
	Question
	Tombstone
	Video
	}
	defp validate_data(cng) do
	cng
	\|> validate_required([:id, :type, :actor, :to, :cc, :object])
	\|> validate_inclusion(:type, ["Delete"])
	\|> validate_delete_actor(:actor)
	\|> validate_modification_rights()
	\|> validate_object_or_user_presence(allowed_types: @deletable_types)
	\|> add_deleted_activity_id()
	end

	def do_not_federate?(cng) do
	!same_domain?(cng)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data
	\|> validate_data
	end

	defp validate_delete_actor(cng, field_name) do
	validate_change(cng, field_name, fn field_name, actor ->
	case User.get_cached_by_ap_id(actor) do
	%User{} -> []
	_ -> [{field_name, "can't find user"}]
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex b/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	index a18bd7540..9eaaf8319 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/emoji_react_validator.ex
	@@ -1,82 +1,83 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator do
	use Ecto.Schema

	- alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	- field(:object, ObjectValidators.ObjectID)
	- field(:actor, ObjectValidators.ObjectID)
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	+
	field(:context, :string)
	field(:content, :string)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	data =
	data
	\|> fix()

	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	end

	defp fix(data) do
	data =
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_activity_addressing()

	with %Object{} = object <- Object.normalize(data["object"]) do
	data
	\|> CommonFixes.fix_activity_context(object)
	\|> CommonFixes.fix_object_action_recipients(object)
	else
	_ -> data
	end
	end

	defp validate_emoji(cng) do
	content = get_field(cng, :content)

	if Pleroma.Emoji.is_unicode_emoji?(content) do
	cng
	else
	cng
	\|> add_error(:content, "must be a single character emoji")
	end
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["EmojiReact"])
	\|> validate_required([:id, :type, :object, :actor, :context, :to, :cc, :content])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_emoji()
	end
	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 fee2e997a..34a3031c3 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/event_validator.ex
	@@ -1,98 +1,71 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.EventValidator do
	use Ecto.Schema

	- alias Pleroma.EctoType.ActivityPub.ObjectValidators
	- alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	- alias Pleroma.Web.ActivityPub.ObjectValidators.TagValidator
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	# Extends from NoteValidator
	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	- field(:bto, ObjectValidators.Recipients, default: [])
	- field(:bcc, ObjectValidators.Recipients, default: [])
	- embeds_many(:tag, TagValidator)
	- field(:type, :string)
	-
	- field(:name, :string)
	- field(:summary, :string)
	- field(:content, :string)
	-
	- field(:context, :string)
	- # short identifier for PleromaFE to group statuses by context
	- field(:context_id, :integer)
	-
	- # TODO: Remove actor on objects
	- field(:actor, ObjectValidators.ObjectID)
	-
	- field(:attributedTo, ObjectValidators.ObjectID)
	- field(:published, ObjectValidators.DateTime)
	- field(:emoji, ObjectValidators.Emoji, default: %{})
	- field(:sensitive, :boolean, default: false)
	- embeds_many(:attachment, AttachmentValidator)
	- field(:replies_count, :integer, default: 0)
	- field(:like_count, :integer, default: 0)
	- field(:announcement_count, :integer, default: 0)
	- field(:inReplyTo, ObjectValidators.ObjectID)
	- field(:url, ObjectValidators.Uri)
	-
	- field(:likes, {:array, ObjectValidators.ObjectID}, default: [])
	- field(:announcements, {:array, ObjectValidators.ObjectID}, default: [])
	+ 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) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix(data) do
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()
	\|> Transmogrifier.fix_emoji()
	end

	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, :context_id])
	\|> 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/follow_validator.ex b/lib/pleroma/web/activity_pub/object_validators/follow_validator.ex
	index 239cee5e7..c061ebba9 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/follow_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/follow_validator.ex
	@@ -1,44 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator do
	use Ecto.Schema

	- alias Pleroma.EctoType.ActivityPub.ObjectValidators
	-
	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	- field(:actor, ObjectValidators.ObjectID)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	- field(:object, ObjectValidators.ObjectID)
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	+
	field(:state, :string, default: "pending")
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	defp validate_data(cng) do
	cng
	\|> validate_required([:id, :type, :actor, :to, :cc, :object])
	\|> validate_inclusion(:type, ["Follow"])
	\|> validate_inclusion(:state, ~w{pending reject accept})
	\|> validate_actor_presence()
	\|> validate_actor_presence(field_name: :object)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data
	\|> validate_data
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/like_validator.ex b/lib/pleroma/web/activity_pub/object_validators/like_validator.ex
	index 8b99c89b9..35e000d72 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/like_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/like_validator.ex
	@@ -1,83 +1,84 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator do
	use Ecto.Schema

	- alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.Utils

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	- field(:object, ObjectValidators.ObjectID)
	- field(:actor, ObjectValidators.ObjectID)
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	+
	field(:context, :string)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	data =
	data
	\|> fix()

	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	end

	defp fix(data) do
	data =
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_activity_addressing()

	with %Object{} = object <- Object.normalize(data["object"]) do
	data
	\|> CommonFixes.fix_activity_context(object)
	\|> CommonFixes.fix_object_action_recipients(object)
	else
	_ -> data
	end
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Like"])
	\|> validate_required([:id, :type, :object, :actor, :context, :to, :cc])
	\|> validate_actor_presence()
	\|> validate_object_presence()
	\|> validate_existing_like()
	end

	defp validate_existing_like(%{changes: %{actor: actor, object: object}} = cng) do
	if Utils.get_existing_like(actor, %{data: %{"id" => object}}) do
	cng
	\|> add_error(:actor, "already liked this object")
	\|> add_error(:object, "already liked by this actor")
	else
	cng
	end
	end

	defp validate_existing_like(cng), do: cng
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/question_validator.ex b/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	index 083d08ec4..bdddfdaeb 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/question_validator.ex
	@@ -1,113 +1,90 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	- alias Pleroma.Web.ActivityPub.ObjectValidators.AttachmentValidator
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonFixes
	alias Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations
	alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionOptionsValidator
	- alias Pleroma.Web.ActivityPub.ObjectValidators.TagValidator
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Ecto.Changeset

	@primary_key false
	@derive Jason.Encoder

	# Extends from NoteValidator
	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	- field(:bto, ObjectValidators.Recipients, default: [])
	- field(:bcc, ObjectValidators.Recipients, default: [])
	- embeds_many(:tag, TagValidator)
	- field(:type, :string)
	- field(:content, :string)
	- field(:context, :string)
	-
	- # TODO: Remove actor on objects
	- field(:actor, ObjectValidators.ObjectID)
	-
	- field(:attributedTo, ObjectValidators.ObjectID)
	- field(:summary, :string)
	- field(:published, ObjectValidators.DateTime)
	- field(:emoji, ObjectValidators.Emoji, default: %{})
	- field(:sensitive, :boolean, default: false)
	- embeds_many(:attachment, AttachmentValidator)
	- field(:replies_count, :integer, default: 0)
	- field(:like_count, :integer, default: 0)
	- field(:announcement_count, :integer, default: 0)
	- field(:inReplyTo, ObjectValidators.ObjectID)
	- field(:url, ObjectValidators.Uri)
	- # short identifier for PleromaFE to group statuses by context
	- field(:context_id, :integer)
	-
	- field(:likes, {:array, ObjectValidators.ObjectID}, default: [])
	- field(:announcements, {:array, ObjectValidators.ObjectID}, default: [])
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ object_fields()
	+ status_object_fields()
	+ end
	+ end

	field(:closed, ObjectValidators.DateTime)
	field(:voters, {:array, ObjectValidators.ObjectID}, default: [])
	embeds_many(:anyOf, QuestionOptionsValidator)
	embeds_many(:oneOf, QuestionOptionsValidator)
	end

	def cast_and_apply(data) do
	data
	\|> cast_data
	\|> apply_action(:insert)
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	defp fix_closed(data) do
	cond do
	is_binary(data["closed"]) -> data
	is_binary(data["endTime"]) -> Map.put(data, "closed", data["endTime"])
	true -> Map.drop(data, ["closed"])
	end
	end

	defp fix(data) do
	data
	\|> CommonFixes.fix_actor()
	\|> CommonFixes.fix_object_defaults()
	\|> Transmogrifier.fix_emoji()
	\|> fix_closed()
	end

	def changeset(struct, data) do
	data = fix(data)

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

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Question"])
	\|> validate_required([:id, :actor, :attributedTo, :type, :context, :context_id])
	\|> CommonValidations.validate_any_presence([:cc, :to])
	\|> CommonValidations.validate_fields_match([:actor, :attributedTo])
	\|> CommonValidations.validate_actor_presence()
	\|> CommonValidations.validate_any_presence([:oneOf, :anyOf])
	\|> CommonValidations.validate_host_match()
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/undo_validator.ex b/lib/pleroma/web/activity_pub/object_validators/undo_validator.ex
	index 6ff648c84..703643e3f 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/undo_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/undo_validator.ex
	@@ -1,72 +1,72 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator do
	use Ecto.Schema

	alias Pleroma.Activity
	- alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.User

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	- field(:object, ObjectValidators.ObjectID)
	- field(:actor, ObjectValidators.ObjectID)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ activity_fields()
	+ end
	+ end
	end

	def cast_and_validate(data) do
	data
	\|> cast_data()
	\|> validate_data()
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> changeset(data)
	end

	def changeset(struct, data) do
	struct
	\|> cast(data, __schema__(:fields))
	end

	defp validate_data(data_cng) do
	data_cng
	\|> validate_inclusion(:type, ["Undo"])
	\|> validate_required([:id, :type, :object, :actor, :to, :cc])
	\|> validate_undo_actor(:actor)
	\|> validate_object_presence()
	\|> validate_undo_rights()
	end

	def validate_undo_rights(cng) do
	actor = get_field(cng, :actor)
	object = get_field(cng, :object)

	with %Activity{data: %{"actor" => object_actor}} <- Activity.get_by_ap_id(object),
	true <- object_actor != actor do
	cng
	\|> add_error(:actor, "not the same as object actor")
	else
	_ -> cng
	end
	end

	defp validate_undo_actor(cng, field_name) do
	validate_change(cng, field_name, fn field_name, actor ->
	case User.get_cached_by_ap_id(actor) do
	%User{} -> []
	_ -> [{field_name, "can't find user"}]
	end
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/object_validators/update_validator.ex b/lib/pleroma/web/activity_pub/object_validators/update_validator.ex
	index 6bb1dc7fa..a1fae47f5 100644
	--- a/lib/pleroma/web/activity_pub/object_validators/update_validator.ex
	+++ b/lib/pleroma/web/activity_pub/object_validators/update_validator.ex
	@@ -1,59 +1,62 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator do
	use Ecto.Schema

	alias Pleroma.EctoType.ActivityPub.ObjectValidators

	import Ecto.Changeset
	import Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations

	@primary_key false

	embedded_schema do
	- field(:id, ObjectValidators.ObjectID, primary_key: true)
	- field(:type, :string)
	+ quote do
	+ unquote do
	+ import Elixir.Pleroma.Web.ActivityPub.ObjectValidators.CommonFields
	+ message_fields()
	+ end
	+ end
	+
	field(:actor, ObjectValidators.ObjectID)
	- field(:to, ObjectValidators.Recipients, default: [])
	- field(:cc, ObjectValidators.Recipients, default: [])
	# In this case, we save the full object in this activity instead of just a
	# reference, so we can always see what was actually changed by this.
	field(:object, :map)
	end

	def cast_data(data) do
	%__MODULE__{}
	\|> cast(data, __schema__(:fields))
	end

	defp validate_data(cng) do
	cng
	\|> validate_required([:id, :type, :actor, :to, :cc, :object])
	\|> validate_inclusion(:type, ["Update"])
	\|> validate_actor_presence()
	\|> validate_updating_rights()
	end

	def cast_and_validate(data) do
	data
	\|> cast_data
	\|> validate_data
	end

	# For now we only support updating users, and here the rule is easy:
	# object id == actor id
	def validate_updating_rights(cng) do
	with actor = get_field(cng, :actor),
	object = get_field(cng, :object),
	{:ok, object_id} <- ObjectValidators.ObjectID.cast(object),
	true <- actor == object_id do
	cng
	else
	_e ->
	cng
	\|> add_error(:object, "Can't be updated by this actor")
	end
	end
	end
	diff --git a/test/pleroma/web/activity_pub/transmogrifier/add_remove_handling_test.exs b/test/pleroma/web/activity_pub/transmogrifier/add_remove_handling_test.exs
	index fc7757125..b17c0e7bf 100644
	--- a/test/pleroma/web/activity_pub/transmogrifier/add_remove_handling_test.exs
	+++ b/test/pleroma/web/activity_pub/transmogrifier/add_remove_handling_test.exs
	@@ -1,172 +1,178 @@
	defmodule Pleroma.Web.ActivityPub.Transmogrifier.AddRemoveHandlingTest do
	use Oban.Testing, repo: Pleroma.Repo
	use Pleroma.DataCase, async: true

	require Pleroma.Constants

	import Pleroma.Factory

	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Transmogrifier

	test "it accepts Add/Remove activities" do
	user =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")

	object_id = "c61d6733-e256-4fe1-ab13-1e369789423f"

	object =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", "lain")
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://example.com/objects/#{object_id}"

	actor = "https://example.com/users/lain"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^actor
	} ->
	%Tesla.Env{
	status: 200,
	body: user,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{method: :get, url: "https://example.com/users/lain/collections/featured"} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/users_mock/masto_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "example.com")
	\|> String.replace("{{nickname}}", "lain"),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	message = %{
	"id" => "https://example.com/objects/d61d6733-e256-4fe1-ab13-1e369789423f",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()],
	- "cc" => ["https://example.com/users/lain/followers"]
	+ "cc" => ["https://example.com/users/lain/followers"],
	+ "bcc" => [],
	+ "bto" => []
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)
	assert activity.data == message
	user = User.get_cached_by_ap_id(actor)
	assert user.pinned_objects[object_url]

	remove = %{
	"id" => "http://localhost:400/objects/d61d6733-e256-4fe1-ab13-1e369789423d",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://example.com/users/lain/collections/featured",
	"type" => "Remove",
	"to" => [Pleroma.Constants.as_public()],
	- "cc" => ["https://example.com/users/lain/followers"]
	+ "cc" => ["https://example.com/users/lain/followers"],
	+ "bcc" => [],
	+ "bto" => []
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(remove)
	assert activity.data == remove

	user = refresh_record(user)
	refute user.pinned_objects[object_url]
	end

	test "Add/Remove activities for remote users without featured address" do
	user = insert(:user, local: false, domain: "example.com")

	user =
	user
	\|> Ecto.Changeset.change(featured_address: nil)
	\|> Repo.update!()

	%{host: host} = URI.parse(user.ap_id)

	user_data =
	"test/fixtures/users_mock/user.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", user.nickname)

	object_id = "c61d6733-e256-4fe1-ab13-1e369789423f"

	object =
	"test/fixtures/statuses/note.json"
	\|> File.read!()
	\|> String.replace("{{nickname}}", user.nickname)
	\|> String.replace("{{object_id}}", object_id)

	object_url = "https://#{host}/objects/#{object_id}"

	actor = "https://#{host}/users/#{user.nickname}"

	featured = "https://#{host}/users/#{user.nickname}/collections/featured"

	Tesla.Mock.mock(fn
	%{
	method: :get,
	url: ^actor
	} ->
	%Tesla.Env{
	status: 200,
	body: user_data,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{
	method: :get,
	url: ^object_url
	} ->
	%Tesla.Env{
	status: 200,
	body: object,
	headers: [{"content-type", "application/activity+json"}]
	}

	%{method: :get, url: ^featured} ->
	%Tesla.Env{
	status: 200,
	body:
	"test/fixtures/users_mock/masto_featured.json"
	\|> File.read!()
	\|> String.replace("{{domain}}", "#{host}")
	\|> String.replace("{{nickname}}", user.nickname),
	headers: [{"content-type", "application/activity+json"}]
	}
	end)

	message = %{
	"id" => "https://#{host}/objects/d61d6733-e256-4fe1-ab13-1e369789423f",
	"actor" => actor,
	"object" => object_url,
	"target" => "https://#{host}/users/#{user.nickname}/collections/featured",
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()],
	- "cc" => ["https://#{host}/users/#{user.nickname}/followers"]
	+ "cc" => ["https://#{host}/users/#{user.nickname}/followers"],
	+ "bcc" => [],
	+ "bto" => []
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)
	assert activity.data == message
	user = User.get_cached_by_ap_id(actor)
	assert user.pinned_objects[object_url]
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 2, 7:37 AM (12 h, 15 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803671
Default Alt Text: (61 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions