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)
319 %{"name" => "#" <> hashtag} -> String.downcase(hashtag)
320 %{"name" => hashtag} -> String.downcase(hashtag)
323 Map.put(object, "tag", tag ++ tags)
326 def fix_tag(%{"tag" => %{} = tag} = object) do
328 |> Map.put("tag", [tag])
332 def fix_tag(object), do: object
334 # content map usually only has one language so this will do for now.
335 def fix_content_map(%{"contentMap" => content_map} = object) do
336 content_groups = Map.to_list(content_map)
337 {_, content} = Enum.at(content_groups, 0)
339 Map.put(object, "content", content)
342 def fix_content_map(object), do: object
344 def fix_type(object, options \\ [])
346 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
347 when is_binary(reply_id) do
348 with true <- Federator.allowed_thread_distance?(options[:depth]),
349 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
350 Map.put(object, "type", "Answer")
356 def fix_type(object, _), do: object
358 # Reduce the object list to find the reported user.
359 defp get_reported(objects) do
360 Enum.reduce_while(objects, nil, fn ap_id, _ ->
361 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
369 # Compatibility wrapper for Mastodon votes
370 defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
371 handle_incoming(data)
374 defp handle_create(%{"object" => object} = data, user) do
379 context: object["context"],
381 published: data["published"],
389 |> ActivityPub.create()
392 def handle_incoming(data, options \\ [])
394 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
396 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
397 with context <- data["context"] || Utils.generate_context_id(),
398 content <- data["content"] || "",
399 %User{} = actor <- User.get_cached_by_ap_id(actor),
400 # Reduce the object list to find the reported user.
401 %User{} = account <- get_reported(objects),
402 # Remove the reported user from the object list.
403 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
410 additional: %{"cc" => [account.ap_id]}
412 |> ActivityPub.flag()
416 # disallow objects with bogus IDs
417 def handle_incoming(%{"id" => nil}, _options), do: :error
418 def handle_incoming(%{"id" => ""}, _options), do: :error
419 # length of https:// = 8, should validate better, but good enough for now.
420 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
423 # TODO: validate those with a Ecto scheme
427 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
430 when objtype in ~w{Note Page} do
431 actor = Containment.get_actor(data)
433 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
434 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
437 |> Map.put("object", fix_object(object, options))
438 |> Map.put("actor", actor)
441 with {:ok, created_activity} <- handle_create(data, user) do
442 reply_depth = (options[:depth] || 0) + 1
444 if Federator.allowed_thread_distance?(reply_depth) do
445 for reply_id <- replies(object) do
446 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
448 "depth" => reply_depth
453 {:ok, created_activity}
456 %Activity{} = activity -> {:ok, activity}
462 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
465 actor = Containment.get_actor(data)
468 Map.put(data, "actor", actor)
471 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
472 reply_depth = (options[:depth] || 0) + 1
473 options = Keyword.put(options, :depth, reply_depth)
474 object = fix_object(object, options)
482 published: data["published"],
483 additional: Map.take(data, ["cc", "id"])
486 ActivityPub.listen(params)
492 @misskey_reactions %{
506 @doc "Rewrite misskey likes into EmojiReacts"
510 "_misskey_reaction" => reaction
515 |> Map.put("type", "EmojiReact")
516 |> Map.put("content", @misskey_reactions[reaction] || reaction)
517 |> handle_incoming(options)
521 %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
524 when objtype in ~w{Question Answer ChatMessage Audio Video Event Article} do
525 data = Map.put(data, "object", strip_internal_fields(data["object"]))
527 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
528 nil <- Activity.get_create_by_object_ap_id(obj_id),
529 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
532 %Activity{} = activity -> {:ok, activity}
537 def handle_incoming(%{"type" => type} = data, _options)
538 when type in ~w{Like EmojiReact Announce} do
539 with :ok <- ObjectValidator.fetch_actor_and_object(data),
540 {:ok, activity, _meta} <-
541 Pipeline.common_pipeline(data, local: false) do
549 %{"type" => type} = data,
552 when type in ~w{Update Block Follow Accept Reject} do
553 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
554 {:ok, activity, _} <-
555 Pipeline.common_pipeline(data, local: false) do
561 %{"type" => "Delete"} = data,
564 with {:ok, activity, _} <-
565 Pipeline.common_pipeline(data, local: false) do
568 {:error, {:validate_object, _}} = e ->
569 # Check if we have a create activity for this
570 with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
571 %Activity{data: %{"actor" => actor}} <-
572 Activity.create_by_object_ap_id(object_id) |> Repo.one(),
573 # We have one, insert a tombstone and retry
574 {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
575 {:ok, _tombstone} <- Object.create(tombstone_data) do
576 handle_incoming(data)
586 "object" => %{"type" => "Follow", "object" => followed},
592 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
593 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
594 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
595 User.unfollow(follower, followed)
605 "object" => %{"type" => type}
609 when type in ["Like", "EmojiReact", "Announce", "Block"] do
610 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
615 # For Undos that don't have the complete object attached, try to find it in our database.
623 when is_binary(object) do
624 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
626 |> Map.put("object", data)
627 |> handle_incoming(options)
636 "actor" => origin_actor,
637 "object" => origin_actor,
638 "target" => target_actor
642 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
643 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
644 true <- origin_actor in target_user.also_known_as do
645 ActivityPub.move(origin_user, target_user, false)
651 def handle_incoming(_, _), do: :error
653 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
654 def get_obj_helper(id, options \\ []) do
655 options = Keyword.put(options, :fetch, true)
657 case Object.normalize(id, options) do
658 %Object{} = object -> {:ok, object}
663 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
664 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
667 when attributed_to == ap_id do
668 with {:ok, activity} <-
673 "actor" => attributed_to,
676 {:ok, Object.normalize(activity, fetch: false)}
678 _ -> get_obj_helper(object_id)
682 def get_embedded_obj_helper(object_id, _) do
683 get_obj_helper(object_id)
686 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
687 with false <- String.starts_with?(in_reply_to, "http"),
688 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
689 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
695 def set_reply_to_uri(obj), do: obj
698 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
699 Based on Mastodon's ActivityPub::NoteSerializer#replies.
701 def set_replies(obj_data) do
703 with limit when limit > 0 <-
704 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
705 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
707 |> Object.self_replies()
708 |> select([o], fragment("?->>'id'", o.data))
715 set_replies(obj_data, replies_uris)
718 defp set_replies(obj, []) do
722 defp set_replies(obj, replies_uris) do
723 replies_collection = %{
724 "type" => "Collection",
725 "items" => replies_uris
728 Map.merge(obj, %{"replies" => replies_collection})
731 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
735 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
739 def replies(_), do: []
741 # Prepares the object of an outgoing create activity.
742 def prepare_object(object) do
749 |> prepare_attachments
753 |> strip_internal_fields
754 |> strip_internal_tags
760 # internal -> Mastodon
763 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
764 when activity_type in ["Create", "Listen"] do
767 |> Object.normalize(fetch: false)
773 |> Map.put("object", object)
774 |> Map.merge(Utils.make_json_ld_header())
780 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
783 |> Object.normalize(fetch: false)
786 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
787 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
789 data |> maybe_fix_object_url
794 |> strip_internal_fields
795 |> Map.merge(Utils.make_json_ld_header())
801 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
802 # because of course it does.
803 def prepare_outgoing(%{"type" => "Accept"} = data) do
804 with follow_activity <- Activity.normalize(data["object"]) do
806 "actor" => follow_activity.actor,
807 "object" => follow_activity.data["object"],
808 "id" => follow_activity.data["id"],
814 |> Map.put("object", object)
815 |> Map.merge(Utils.make_json_ld_header())
821 def prepare_outgoing(%{"type" => "Reject"} = data) do
822 with follow_activity <- Activity.normalize(data["object"]) do
824 "actor" => follow_activity.actor,
825 "object" => follow_activity.data["object"],
826 "id" => follow_activity.data["id"],
832 |> Map.put("object", object)
833 |> Map.merge(Utils.make_json_ld_header())
839 def prepare_outgoing(%{"type" => _type} = data) do
842 |> strip_internal_fields
843 |> maybe_fix_object_url
844 |> Map.merge(Utils.make_json_ld_header())
849 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
850 with false <- String.starts_with?(object, "http"),
851 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
852 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
854 Map.put(data, "object", external_url)
857 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
865 def maybe_fix_object_url(data), do: data
867 def add_hashtags(object) do
869 (object["tag"] || [])
871 # Expand internal representation tags into AS2 tags.
872 tag when is_binary(tag) ->
874 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
879 # Do not process tags which are already AS2 tag objects.
880 tag when is_map(tag) ->
884 Map.put(object, "tag", tags)
887 # TODO These should be added on our side on insertion, it doesn't make much
888 # sense to regenerate these all the time
889 def add_mention_tags(object) do
890 to = object["to"] || []
891 cc = object["cc"] || []
892 mentioned = User.get_users_from_set(to ++ cc, local_only: false)
894 mentions = Enum.map(mentioned, &build_mention_tag/1)
896 tags = object["tag"] || []
897 Map.put(object, "tag", tags ++ mentions)
900 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
901 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
904 def take_emoji_tags(%User{emoji: emoji}) do
907 |> Enum.map(&build_emoji_tag/1)
910 # TODO: we should probably send mtime instead of unix epoch time for updated
911 def add_emoji_tags(%{"emoji" => emoji} = object) do
912 tags = object["tag"] || []
914 out = Enum.map(emoji, &build_emoji_tag/1)
916 Map.put(object, "tag", tags ++ out)
919 def add_emoji_tags(object), do: object
921 defp build_emoji_tag({name, url}) do
923 "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
924 "name" => ":" <> name <> ":",
926 "updated" => "1970-01-01T00:00:00Z",
931 def set_conversation(object) do
932 Map.put(object, "conversation", object["context"])
935 def set_sensitive(%{"sensitive" => _} = object) do
939 def set_sensitive(object) do
940 tags = object["tag"] || []
941 Map.put(object, "sensitive", "nsfw" in tags)
944 def set_type(%{"type" => "Answer"} = object) do
945 Map.put(object, "type", "Note")
948 def set_type(object), do: object
950 def add_attributed_to(object) do
951 attributed_to = object["attributedTo"] || object["actor"]
952 Map.put(object, "attributedTo", attributed_to)
956 def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
958 def prepare_attachments(object) do
961 |> Map.get("attachment", [])
962 |> Enum.map(fn data ->
963 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
967 "mediaType" => media_type,
968 "name" => data["name"],
973 Map.put(object, "attachment", attachments)
976 def strip_internal_fields(object) do
977 Map.drop(object, Pleroma.Constants.object_internal_fields())
980 defp strip_internal_tags(%{"tag" => tags} = object) do
981 tags = Enum.filter(tags, fn x -> is_map(x) end)
983 Map.put(object, "tag", tags)
986 defp strip_internal_tags(object), do: object
988 def perform(:user_upgrade, user) do
989 # we pass a fake user so that the followers collection is stripped away
990 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
994 where: ^old_follower_address in a.recipients,
999 "array_replace(?,?,?)",
1001 ^old_follower_address,
1002 ^user.follower_address
1007 |> Repo.update_all([])
1010 def upgrade_user_from_ap_id(ap_id) do
1011 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1012 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1013 {:ok, user} <- update_user(user, data) do
1014 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1017 %User{} = user -> {:ok, user}
1022 defp update_user(user, data) do
1024 |> User.remote_user_changeset(data)
1025 |> User.update_and_set_cache()
1028 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1029 Map.put(data, "url", url["href"])
1032 def maybe_fix_user_url(data), do: data
1034 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)