builder.ex
No OneTemporary
Actions

Size

11 KB

Referenced Files

None

Subscribers

None

builder.ex
View Options

	# 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.Builder do
	@moduledoc """
	This module builds the objects. Meant to be used for creating local objects.

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

	alias Pleroma.Activity
	alias Pleroma.Emoji
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI.ActivityDraft

	require Pleroma.Constants

	def accept_or_reject(actor, activity, type) do
	data = %{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => type,
	"object" => activity.data["id"],
	"to" => [activity.actor]
	}

	{:ok, data, []}
	end

	@spec reject(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def reject(actor, rejected_activity) do
	accept_or_reject(actor, rejected_activity, "Reject")
	end

	@spec accept(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def accept(actor, accepted_activity) do
	accept_or_reject(actor, accepted_activity, "Accept")
	end

	@spec follow(User.t(), User.t()) :: {:ok, map(), keyword()}
	def follow(follower, followed) do
	data = %{
	"id" => Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"to" => [followed.ap_id]
	}

	{:ok, data, []}
	end

	defp unicode_emoji_react(_object, data, emoji) do
	data
	\|> Map.put("content", emoji)
	\|> Map.put("type", "EmojiReact")
	end

	defp add_emoji_content(data, emoji, url) do
	tag = [
	Emoji.build_emoji_tag({Emoji.maybe_strip_name(emoji), url})
	]

	data
	\|> Map.put("content", Emoji.maybe_quote(emoji))
	\|> Map.put("type", "EmojiReact")
	\|> Map.put("tag", tag)
	end

	defp remote_custom_emoji_react(
	%{data: %{"reactions" => existing_reactions}},
	data,
	emoji
	) do
	[emoji_code, instance] = String.split(Emoji.maybe_strip_name(emoji), "@")

	matching_reaction =
	Enum.find(
	existing_reactions,
	fn [name, _, url] ->
	if url != nil do
	url = URI.parse(url)
	url.host == instance && name == emoji_code
	end
	end
	)

	if matching_reaction do
	[name, _, url] = matching_reaction
	add_emoji_content(data, name, url)
	else
	{:error, "Could not react"}
	end
	end

	defp remote_custom_emoji_react(_object, _data, _emoji) do
	{:error, "Could not react"}
	end

	defp local_custom_emoji_react(data, emoji) do
	with %{file: path} = emojo <- Emoji.get(emoji) do
	url = Emoji.local_url(path)
	add_emoji_content(data, emojo.code, url)
	else
	_ -> {:error, "Emoji does not exist"}
	end
	end

	defp custom_emoji_react(object, data, emoji) do
	if String.contains?(emoji, "@") do
	remote_custom_emoji_react(object, data, emoji)
	else
	local_custom_emoji_react(data, emoji)
	end
	end

	@spec emoji_react(User.t(), Object.t(), String.t()) :: {:ok, map(), keyword()}
	def emoji_react(actor, object, emoji) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	if Emoji.unicode?(emoji) do
	unicode_emoji_react(object, data, emoji)
	else
	custom_emoji_react(object, data, emoji)
	end

	{:ok, data, meta}
	end
	end

	@spec undo(User.t(), Activity.t()) :: {:ok, map(), keyword()}
	def undo(actor, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"type" => "Undo",
	"object" => object.data["id"],
	"to" => object.data["to"] \|\| [],
	"cc" => object.data["cc"] \|\| []
	}, []}
	end

	@spec delete(User.t(), String.t()) :: {:ok, map(), keyword()}
	def delete(actor, object_id) do
	object = Object.normalize(object_id, fetch: false)

	user = !object && User.get_cached_by_ap_id(object_id)

	to =
	case {object, user} do
	{%Object{}, _} ->
	# We are deleting an object, address everyone who was originally mentioned
	(object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	{_, %User{follower_address: follower_address}} ->
	# We are deleting a user, address the followers of that user
	[follower_address]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object_id,
	"to" => to,
	"type" => "Delete"
	}, []}
	end

	def create(actor, object, recipients) do
	context =
	if is_map(object) do
	object["context"]
	else
	nil
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"to" => recipients,
	"object" => object,
	"type" => "Create",
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}
	\|> Pleroma.Maps.put_if_present("context", context), []}
	end

	@spec note(ActivityDraft.t()) :: {:ok, map(), keyword()}
	def note(%ActivityDraft{} = draft) do
	data =
	%{
	"type" => "Note",
	"to" => draft.to,
	"cc" => draft.cc,
	"content" => draft.content_html,
	"summary" => draft.summary,
	"sensitive" => draft.sensitive,
	"context" => draft.context,
	"attachment" => draft.attachments,
	"actor" => draft.user.ap_id,
	"tag" => Keyword.values(draft.tags) \|> Enum.uniq()
	}
	\|> add_in_reply_to(draft.in_reply_to)
	\|> add_quote(draft.quote_post)
	\|> Map.merge(draft.extra)

	{:ok, data, []}
	end

	defp add_in_reply_to(object, nil), do: object

	defp add_in_reply_to(object, in_reply_to) do
	with %Object{} = in_reply_to_object <- Object.normalize(in_reply_to, fetch: false) do
	Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
	else
	_ -> object
	end
	end

	defp add_quote(object, nil), do: object

	defp add_quote(object, quote_post) do
	with %Object{} = quote_object <- Object.normalize(quote_post, fetch: false) do
	Map.put(object, "quoteUrl", quote_object.data["id"])
	else
	_ -> object
	end
	end

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

	case opts[:attachment] do
	%Object{data: attachment_data} ->
	{
	:ok,
	Map.put(basic, "attachment", attachment_data),
	[]
	}

	_ ->
	{:ok, basic, []}
	end
	end

	def answer(user, object, name) do
	{:ok,
	%{
	"type" => "Answer",
	"actor" => user.ap_id,
	"attributedTo" => user.ap_id,
	"cc" => [object.data["actor"]],
	"to" => [],
	"name" => name,
	"inReplyTo" => object.data["id"],
	"context" => object.data["context"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"id" => Utils.generate_object_id()
	}, []}
	end

	@spec tombstone(String.t(), String.t()) :: {:ok, map(), keyword()}
	def tombstone(actor, id) do
	{:ok,
	%{
	"id" => id,
	"actor" => actor,
	"type" => "Tombstone"
	}, []}
	end

	@spec like(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def like(actor, object) do
	with {:ok, data, meta} <- object_action(actor, object) do
	data =
	data
	\|> Map.put("type", "Like")

	{:ok, data, meta}
	end
	end

	@spec update(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def update(actor, object) do
	{to, cc} =
	if object["type"] in Pleroma.Constants.actor_types() do
	# User updates, always public
	{[Pleroma.Constants.as_public(), actor.follower_address], []}
	else
	# Status updates, follow the recipients in the object
	{object["to"] \|\| [], object["cc"] \|\| []}
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Update",
	"actor" => actor.ap_id,
	"object" => object,
	"to" => to,
	"cc" => cc
	}, []}
	end

	@spec block(User.t(), User.t(), map()) :: {:ok, map(), keyword()}
	def block(blocker, blocked, params \\ %{}) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"type" => "Block",
	"actor" => blocker.ap_id,
	"object" => blocked.ap_id,
	"to" => [blocked.ap_id]
	}, Keyword.new(params)}
	end

	@spec announce(User.t(), Object.t(), keyword()) :: {:ok, map(), keyword()}
	def announce(actor, object, options \\ []) do
	public? = Keyword.get(options, :public, false)

	to =
	cond do
	actor.ap_id == Relay.ap_id() ->
	[actor.follower_address]

	public? and Visibility.local_public?(object) ->
	[actor.follower_address, object.data["actor"], Utils.as_local_public()]

	public? ->
	[actor.follower_address, object.data["actor"], Pleroma.Constants.as_public()]

	true ->
	[actor.follower_address, object.data["actor"]]
	end

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"context" => object.data["context"],
	"type" => "Announce",
	"published" => Utils.make_date()
	}, []}
	end

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

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

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

	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"actor" => actor.ap_id,
	"object" => object.data["id"],
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}, []}
	end

	@spec pin(User.t(), Object.t()) :: {:ok, map(), keyword()}
	def pin(%User{} = user, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"target" => pinned_url(user.nickname),
	"object" => object.data["id"],
	"actor" => user.ap_id,
	"type" => "Add",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}, []}
	end

	@spec unpin(User.t(), Object.t()) :: {:ok, map, keyword()}
	def unpin(%User{} = user, object) do
	{:ok,
	%{
	"id" => Utils.generate_activity_id(),
	"target" => pinned_url(user.nickname),
	"object" => object.data["id"],
	"actor" => user.ap_id,
	"type" => "Remove",
	"to" => [Pleroma.Constants.as_public()],
	"cc" => [user.follower_address]
	}, []}
	end

	defp pinned_url(nickname) when is_binary(nickname) do
	Pleroma.Web.Router.Helpers.activity_pub_url(Pleroma.Web.Endpoint, :pinned, nickname)
	end
	end

File Metadata

Mime Type: text/x-ruby
Expires: Tue, Jan 20, 2:04 PM (47 m, 44 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 973852
Default Alt Text: builder.ex (11 KB)

builder.exNo OneTemporaryActions

builder.exView Options

File Metadata

Event Timeline

builder.ex
No OneTemporary
Actions

builder.ex
View Options