1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.Transmogrifier do
7 A module to handle coding from internal to wire ActivityPub and back.
10 alias Pleroma.EctoType.ActivityPub.ObjectValidators
13 alias Pleroma.Object.Containment
16 alias Pleroma.Web.ActivityPub.ActivityPub
17 alias Pleroma.Web.ActivityPub.Builder
18 alias Pleroma.Web.ActivityPub.ObjectValidator
19 alias Pleroma.Web.ActivityPub.Pipeline
20 alias Pleroma.Web.ActivityPub.Utils
21 alias Pleroma.Web.ActivityPub.Visibility
22 alias Pleroma.Web.Federator
23 alias Pleroma.Workers.TransmogrifierWorker
28 require Pleroma.Constants
31 Modifies an incoming AP object (mastodon format) to our internal format.
33 def fix_object(object, options \\ []) do
35 |> strip_internal_fields
40 |> fix_in_reply_to(options)
50 def fix_summary(%{"summary" => nil} = object) do
51 Map.put(object, "summary", "")
54 def fix_summary(%{"summary" => _} = object) do
55 # summary is present, nothing to do
59 def fix_summary(object), do: Map.put(object, "summary", "")
61 def fix_addressing_list(map, field) do
66 Map.put(map, field, Enum.filter(addrs, &is_binary/1))
69 Map.put(map, field, [addrs])
72 Map.put(map, field, [])
76 def fix_explicit_addressing(
77 %{"to" => to, "cc" => cc} = object,
81 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
83 explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
87 |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
91 |> Map.put("to", explicit_to)
92 |> Map.put("cc", final_cc)
95 def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
97 # if directMessage flag is set to true, leave the addressing alone
98 def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
100 def fix_explicit_addressing(object) do
101 explicit_mentions = Utils.determine_explicit_mentions(object)
103 %User{follower_address: follower_collection} =
105 |> Containment.get_actor()
106 |> User.get_cached_by_ap_id()
111 Pleroma.Constants.as_public(),
115 fix_explicit_addressing(object, explicit_mentions, follower_collection)
118 # if as:Public is addressed, then make sure the followers collection is also addressed
119 # so that the activities will be delivered to local users.
120 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
121 recipients = to ++ cc
123 if followers_collection not in recipients do
125 Pleroma.Constants.as_public() in cc ->
126 to = to ++ [followers_collection]
127 Map.put(object, "to", to)
129 Pleroma.Constants.as_public() in to ->
130 cc = cc ++ [followers_collection]
131 Map.put(object, "cc", cc)
141 def fix_implicit_addressing(object, _), do: object
143 def fix_addressing(object) do
144 {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
145 followers_collection = User.ap_followers(user)
148 |> fix_addressing_list("to")
149 |> fix_addressing_list("cc")
150 |> fix_addressing_list("bto")
151 |> fix_addressing_list("bcc")
152 |> fix_explicit_addressing()
153 |> fix_implicit_addressing(followers_collection)
156 def fix_actor(%{"attributedTo" => actor} = object) do
157 actor = Containment.get_actor(%{"actor" => actor})
159 # TODO: Remove actor field for Objects
161 |> Map.put("actor", actor)
162 |> Map.put("attributedTo", actor)
165 def fix_in_reply_to(object, options \\ [])
167 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
168 when not is_nil(in_reply_to) do
169 in_reply_to_id = prepare_in_reply_to(in_reply_to)
170 depth = (options[:depth] || 0) + 1
172 if Federator.allowed_thread_distance?(depth) do
173 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
174 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
176 |> Map.put("inReplyTo", replied_object.data["id"])
177 |> Map.put("context", replied_object.data["context"] || object["conversation"])
178 |> Map.drop(["conversation", "inReplyToAtomUri"])
181 Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
189 def fix_in_reply_to(object, _options), do: object
191 defp prepare_in_reply_to(in_reply_to) do
193 is_bitstring(in_reply_to) ->
196 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
199 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
200 Enum.at(in_reply_to, 0)
207 def fix_context(object) do
208 context = object["context"] || object["conversation"] || Utils.generate_context_id()
211 |> Map.put("context", context)
212 |> Map.drop(["conversation"])
215 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
217 Enum.map(attachment, fn data ->
220 is_list(data["url"]) -> List.first(data["url"])
221 is_map(data["url"]) -> data["url"]
227 is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
228 MIME.valid?(data["mediaType"]) -> data["mediaType"]
229 MIME.valid?(data["mimeType"]) -> data["mimeType"]
235 is_map(url) && is_binary(url["href"]) -> url["href"]
236 is_binary(data["url"]) -> data["url"]
237 is_binary(data["href"]) -> data["href"]
245 "type" => Map.get(url || %{}, "type", "Link")
247 |> Maps.put_if_present("mediaType", media_type)
250 "url" => [attachment_url],
251 "type" => data["type"] || "Document"
253 |> Maps.put_if_present("mediaType", media_type)
254 |> Maps.put_if_present("name", data["name"])
255 |> Maps.put_if_present("blurhash", data["blurhash"])
262 Map.put(object, "attachment", attachments)
265 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
267 |> Map.put("attachment", [attachment])
271 def fix_attachments(object), do: object
273 def fix_url(%{"url" => url} = object) when is_map(url) do
274 Map.put(object, "url", url["href"])
277 def fix_url(%{"url" => url} = object) when is_list(url) do
278 first_element = Enum.at(url, 0)
282 is_bitstring(first_element) -> first_element
283 is_map(first_element) -> first_element["href"] || ""
287 Map.put(object, "url", url_string)
290 def fix_url(object), do: object
292 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
295 |> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
296 |> Enum.reduce(%{}, fn data, mapping ->
297 name = String.trim(data["name"], ":")
299 Map.put(mapping, name, data["icon"]["url"])
302 Map.put(object, "emoji", emoji)
305 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
306 name = String.trim(tag["name"], ":")
307 emoji = %{name => tag["icon"]["url"]}
309 Map.put(object, "emoji", emoji)
312 def fix_emoji(object), do: object
314 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
317 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
318 |> Enum.map(fn %{"name" => name} ->
320 |> String.slice(1..-1)
324 Map.put(object, "tag", tag ++ tags)
327 def fix_tag(%{"tag" => %{} = tag} = object) do
329 |> Map.put("tag", [tag])
333 def fix_tag(object), do: object
335 # content map usually only has one language so this will do for now.
336 def fix_content_map(%{"contentMap" => content_map} = object) do
337 content_groups = Map.to_list(content_map)
338 {_, content} = Enum.at(content_groups, 0)
340 Map.put(object, "content", content)
343 def fix_content_map(object), do: object
345 def fix_type(object, options \\ [])
347 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
348 when is_binary(reply_id) do
349 with true <- Federator.allowed_thread_distance?(options[:depth]),
350 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
351 Map.put(object, "type", "Answer")
357 def fix_type(object, _), do: object
359 # Reduce the object list to find the reported user.
360 defp get_reported(objects) do
361 Enum.reduce_while(objects, nil, fn ap_id, _ ->
362 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
370 # Compatibility wrapper for Mastodon votes
371 defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
372 handle_incoming(data)
375 defp handle_create(%{"object" => object} = data, user) do
380 context: object["context"],
382 published: data["published"],
390 |> ActivityPub.create()
393 def handle_incoming(data, options \\ [])
395 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
397 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
398 with context <- data["context"] || Utils.generate_context_id(),
399 content <- data["content"] || "",
400 %User{} = actor <- User.get_cached_by_ap_id(actor),
401 # Reduce the object list to find the reported user.
402 %User{} = account <- get_reported(objects),
403 # Remove the reported user from the object list.
404 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
411 additional: %{"cc" => [account.ap_id]}
413 |> ActivityPub.flag()
417 # disallow objects with bogus IDs
418 def handle_incoming(%{"id" => nil}, _options), do: :error
419 def handle_incoming(%{"id" => ""}, _options), do: :error
420 # length of https:// = 8, should validate better, but good enough for now.
421 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
424 # TODO: validate those with a Ecto scheme
428 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
431 when objtype in ~w{Note Page} do
432 actor = Containment.get_actor(data)
434 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
435 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
438 |> Map.put("object", fix_object(object, options))
439 |> Map.put("actor", actor)
442 with {:ok, created_activity} <- handle_create(data, user) do
443 reply_depth = (options[:depth] || 0) + 1
445 if Federator.allowed_thread_distance?(reply_depth) do
446 for reply_id <- replies(object) do
447 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
449 "depth" => reply_depth
454 {:ok, created_activity}
457 %Activity{} = activity -> {:ok, activity}
463 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
466 actor = Containment.get_actor(data)
469 Map.put(data, "actor", actor)
472 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
473 reply_depth = (options[:depth] || 0) + 1
474 options = Keyword.put(options, :depth, reply_depth)
475 object = fix_object(object, options)
483 published: data["published"],
484 additional: Map.take(data, ["cc", "id"])
487 ActivityPub.listen(params)
493 @misskey_reactions %{
507 @doc "Rewrite misskey likes into EmojiReacts"
511 "_misskey_reaction" => reaction
516 |> Map.put("type", "EmojiReact")
517 |> Map.put("content", @misskey_reactions[reaction] || reaction)
518 |> handle_incoming(options)
522 %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
525 when objtype in ~w{Question Answer ChatMessage Audio Video Event Article} do
526 data = Map.put(data, "object", strip_internal_fields(data["object"]))
528 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
529 nil <- Activity.get_create_by_object_ap_id(obj_id),
530 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
533 %Activity{} = activity -> {:ok, activity}
538 def handle_incoming(%{"type" => type} = data, _options)
539 when type in ~w{Like EmojiReact Announce} do
540 with :ok <- ObjectValidator.fetch_actor_and_object(data),
541 {:ok, activity, _meta} <-
542 Pipeline.common_pipeline(data, local: false) do
550 %{"type" => type} = data,
553 when type in ~w{Update Block Follow Accept Reject} do
554 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
555 {:ok, activity, _} <-
556 Pipeline.common_pipeline(data, local: false) do
562 %{"type" => "Delete"} = data,
565 with {:ok, activity, _} <-
566 Pipeline.common_pipeline(data, local: false) do
569 {:error, {:validate_object, _}} = e ->
570 # Check if we have a create activity for this
571 with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
572 %Activity{data: %{"actor" => actor}} <-
573 Activity.create_by_object_ap_id(object_id) |> Repo.one(),
574 # We have one, insert a tombstone and retry
575 {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
576 {:ok, _tombstone} <- Object.create(tombstone_data) do
577 handle_incoming(data)
587 "object" => %{"type" => "Follow", "object" => followed},
593 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
594 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
595 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
596 User.unfollow(follower, followed)
606 "object" => %{"type" => type}
610 when type in ["Like", "EmojiReact", "Announce", "Block"] do
611 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
616 # For Undos that don't have the complete object attached, try to find it in our database.
624 when is_binary(object) do
625 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
627 |> Map.put("object", data)
628 |> handle_incoming(options)
637 "actor" => origin_actor,
638 "object" => origin_actor,
639 "target" => target_actor
643 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
644 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
645 true <- origin_actor in target_user.also_known_as do
646 ActivityPub.move(origin_user, target_user, false)
652 def handle_incoming(_, _), do: :error
654 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
655 def get_obj_helper(id, options \\ []) do
656 options = Keyword.put(options, :fetch, true)
658 case Object.normalize(id, options) do
659 %Object{} = object -> {:ok, object}
664 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
665 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
668 when attributed_to == ap_id do
669 with {:ok, activity} <-
674 "actor" => attributed_to,
677 {:ok, Object.normalize(activity, fetch: false)}
679 _ -> get_obj_helper(object_id)
683 def get_embedded_obj_helper(object_id, _) do
684 get_obj_helper(object_id)
687 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
688 with false <- String.starts_with?(in_reply_to, "http"),
689 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
690 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
696 def set_reply_to_uri(obj), do: obj
699 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
700 Based on Mastodon's ActivityPub::NoteSerializer#replies.
702 def set_replies(obj_data) do
704 with limit when limit > 0 <-
705 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
706 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
708 |> Object.self_replies()
709 |> select([o], fragment("?->>'id'", o.data))
716 set_replies(obj_data, replies_uris)
719 defp set_replies(obj, []) do
723 defp set_replies(obj, replies_uris) do
724 replies_collection = %{
725 "type" => "Collection",
726 "items" => replies_uris
729 Map.merge(obj, %{"replies" => replies_collection})
732 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
736 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
740 def replies(_), do: []
742 # Prepares the object of an outgoing create activity.
743 def prepare_object(object) do
750 |> prepare_attachments
754 |> strip_internal_fields
755 |> strip_internal_tags
761 # internal -> Mastodon
764 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
765 when activity_type in ["Create", "Listen"] do
768 |> Object.normalize(fetch: false)
774 |> Map.put("object", object)
775 |> Map.merge(Utils.make_json_ld_header())
781 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
784 |> Object.normalize(fetch: false)
787 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
788 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
790 data |> maybe_fix_object_url
795 |> strip_internal_fields
796 |> Map.merge(Utils.make_json_ld_header())
802 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
803 # because of course it does.
804 def prepare_outgoing(%{"type" => "Accept"} = data) do
805 with follow_activity <- Activity.normalize(data["object"]) do
807 "actor" => follow_activity.actor,
808 "object" => follow_activity.data["object"],
809 "id" => follow_activity.data["id"],
815 |> Map.put("object", object)
816 |> Map.merge(Utils.make_json_ld_header())
822 def prepare_outgoing(%{"type" => "Reject"} = data) do
823 with follow_activity <- Activity.normalize(data["object"]) do
825 "actor" => follow_activity.actor,
826 "object" => follow_activity.data["object"],
827 "id" => follow_activity.data["id"],
833 |> Map.put("object", object)
834 |> Map.merge(Utils.make_json_ld_header())
840 def prepare_outgoing(%{"type" => _type} = data) do
843 |> strip_internal_fields
844 |> maybe_fix_object_url
845 |> Map.merge(Utils.make_json_ld_header())
850 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
851 with false <- String.starts_with?(object, "http"),
852 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
853 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
855 Map.put(data, "object", external_url)
858 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
866 def maybe_fix_object_url(data), do: data
868 def add_hashtags(object) do
870 (object["tag"] || [])
872 # Expand internal representation tags into AS2 tags.
873 tag when is_binary(tag) ->
875 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
880 # Do not process tags which are already AS2 tag objects.
881 tag when is_map(tag) ->
885 Map.put(object, "tag", tags)
888 # TODO These should be added on our side on insertion, it doesn't make much
889 # sense to regenerate these all the time
890 def add_mention_tags(object) do
891 to = object["to"] || []
892 cc = object["cc"] || []
893 mentioned = User.get_users_from_set(to ++ cc, local_only: false)
895 mentions = Enum.map(mentioned, &build_mention_tag/1)
897 tags = object["tag"] || []
898 Map.put(object, "tag", tags ++ mentions)
901 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
902 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
905 def take_emoji_tags(%User{emoji: emoji}) do
908 |> Enum.map(&build_emoji_tag/1)
911 # TODO: we should probably send mtime instead of unix epoch time for updated
912 def add_emoji_tags(%{"emoji" => emoji} = object) do
913 tags = object["tag"] || []
915 out = Enum.map(emoji, &build_emoji_tag/1)
917 Map.put(object, "tag", tags ++ out)
920 def add_emoji_tags(object), do: object
922 defp build_emoji_tag({name, url}) do
924 "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
925 "name" => ":" <> name <> ":",
927 "updated" => "1970-01-01T00:00:00Z",
932 def set_conversation(object) do
933 Map.put(object, "conversation", object["context"])
936 def set_sensitive(%{"sensitive" => _} = object) do
940 def set_sensitive(object) do
941 tags = object["tag"] || []
942 Map.put(object, "sensitive", "nsfw" in tags)
945 def set_type(%{"type" => "Answer"} = object) do
946 Map.put(object, "type", "Note")
949 def set_type(object), do: object
951 def add_attributed_to(object) do
952 attributed_to = object["attributedTo"] || object["actor"]
953 Map.put(object, "attributedTo", attributed_to)
957 def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
959 def prepare_attachments(object) do
962 |> Map.get("attachment", [])
963 |> Enum.map(fn data ->
964 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
968 "mediaType" => media_type,
969 "name" => data["name"],
974 Map.put(object, "attachment", attachments)
977 def strip_internal_fields(object) do
978 Map.drop(object, Pleroma.Constants.object_internal_fields())
981 defp strip_internal_tags(%{"tag" => tags} = object) do
982 tags = Enum.filter(tags, fn x -> is_map(x) end)
984 Map.put(object, "tag", tags)
987 defp strip_internal_tags(object), do: object
989 def perform(:user_upgrade, user) do
990 # we pass a fake user so that the followers collection is stripped away
991 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
995 where: ^old_follower_address in a.recipients,
1000 "array_replace(?,?,?)",
1002 ^old_follower_address,
1003 ^user.follower_address
1008 |> Repo.update_all([])
1011 def upgrade_user_from_ap_id(ap_id) do
1012 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1013 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1014 {:ok, user} <- update_user(user, data) do
1015 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1018 %User{} = user -> {:ok, user}
1023 defp update_user(user, data) do
1025 |> User.remote_user_changeset(data)
1026 |> User.update_and_set_cache()
1029 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1030 Map.put(data, "url", url["href"])
1033 def maybe_fix_user_url(data), do: data
1035 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)