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)
41 |> fix_quote_url(options)
49 def fix_summary(%{"summary" => nil} = object) do
50 Map.put(object, "summary", "")
53 def fix_summary(%{"summary" => _} = object) do
54 # summary is present, nothing to do
58 def fix_summary(object), do: Map.put(object, "summary", "")
60 def fix_addressing_list(map, field) do
65 Map.put(map, field, Enum.filter(addrs, &is_binary/1))
68 Map.put(map, field, [addrs])
71 Map.put(map, field, [])
75 # if directMessage flag is set to true, leave the addressing alone
76 def fix_explicit_addressing(%{"directMessage" => true} = object, _follower_collection),
79 def fix_explicit_addressing(%{"to" => to, "cc" => cc} = object, follower_collection) do
81 Utils.determine_explicit_mentions(object) ++
82 [Pleroma.Constants.as_public(), follower_collection]
84 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
85 explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
90 |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
94 |> Map.put("to", explicit_to)
95 |> Map.put("cc", final_cc)
98 # if as:Public is addressed, then make sure the followers collection is also addressed
99 # so that the activities will be delivered to local users.
100 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
101 recipients = to ++ cc
103 if followers_collection not in recipients do
105 Pleroma.Constants.as_public() in cc ->
106 to = to ++ [followers_collection]
107 Map.put(object, "to", to)
109 Pleroma.Constants.as_public() in to ->
110 cc = cc ++ [followers_collection]
111 Map.put(object, "cc", cc)
121 def fix_addressing(object) do
122 {:ok, %User{follower_address: follower_collection}} =
124 |> Containment.get_actor()
125 |> User.get_or_fetch_by_ap_id()
128 |> fix_addressing_list("to")
129 |> fix_addressing_list("cc")
130 |> fix_addressing_list("bto")
131 |> fix_addressing_list("bcc")
132 |> fix_explicit_addressing(follower_collection)
133 |> fix_implicit_addressing(follower_collection)
136 def fix_actor(%{"attributedTo" => actor} = object) do
137 actor = Containment.get_actor(%{"actor" => actor})
139 # TODO: Remove actor field for Objects
141 |> Map.put("actor", actor)
142 |> Map.put("attributedTo", actor)
145 def fix_in_reply_to(object, options \\ [])
147 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
148 when not is_nil(in_reply_to) do
149 in_reply_to_id = prepare_in_reply_to(in_reply_to)
150 depth = (options[:depth] || 0) + 1
152 if Federator.allowed_thread_distance?(depth) do
153 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
154 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
156 |> Map.put("inReplyTo", replied_object.data["id"])
157 |> Map.put("context", replied_object.data["context"] || object["conversation"])
158 |> Map.drop(["conversation", "inReplyToAtomUri"])
161 Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
169 def fix_in_reply_to(object, _options), do: object
171 def fix_quote_url(object, options \\ [])
173 def fix_quote_url(%{"quoteUri" => quote_url} = object, options)
174 when not is_nil(quote_url) do
175 depth = (options[:depth] || 0) + 1
177 if Federator.allowed_thread_distance?(depth) do
178 with {:ok, quoted_object} <- get_obj_helper(quote_url, options),
179 %Activity{} <- Activity.get_create_by_object_ap_id(quoted_object.data["id"]) do
181 |> Map.put("quoteUri", quoted_object.data["id"])
184 Logger.warn("Couldn't fetch #{inspect(quote_url)}, error: #{inspect(e)}")
193 def fix_quote_url(%{"quoteUrl" => quote_url} = object, options) do
195 |> Map.put("quoteUri", quote_url)
196 |> fix_quote_url(options)
200 # https://github.com/fedibird/mastodon/issues/9
201 def fix_quote_url(%{"quoteURL" => quote_url} = object, options) do
203 |> Map.put("quoteUri", quote_url)
204 |> Map.delete("quoteURL")
205 |> fix_quote_url(options)
208 def fix_quote_url(%{"_misskey_quote" => quote_url} = object, options) do
210 |> Map.put("quoteUri", quote_url)
211 |> Map.delete("_misskey_quote")
212 |> fix_quote_url(options)
215 def fix_quote_url(object, _), do: object
217 defp prepare_in_reply_to(in_reply_to) do
219 is_bitstring(in_reply_to) ->
222 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
225 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
226 Enum.at(in_reply_to, 0)
233 def fix_context(object) do
234 context = object["context"] || object["conversation"] || Utils.generate_context_id()
237 |> Map.put("context", context)
238 |> Map.drop(["conversation"])
241 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
243 Enum.map(attachment, fn data ->
246 is_list(data["url"]) -> List.first(data["url"])
247 is_map(data["url"]) -> data["url"]
253 is_map(url) && MIME.extensions(url["mediaType"]) != [] ->
256 is_bitstring(data["mediaType"]) && MIME.extensions(data["mediaType"]) != [] ->
259 is_bitstring(data["mimeType"]) && MIME.extensions(data["mimeType"]) != [] ->
268 is_map(url) && is_binary(url["href"]) -> url["href"]
269 is_binary(data["url"]) -> data["url"]
270 is_binary(data["href"]) -> data["href"]
278 "type" => Map.get(url || %{}, "type", "Link")
280 |> Maps.put_if_present("mediaType", media_type)
281 |> Maps.put_if_present("width", (url || %{})["width"] || data["width"])
282 |> Maps.put_if_present("height", (url || %{})["height"] || data["height"])
285 "url" => [attachment_url],
286 "type" => data["type"] || "Document"
288 |> Maps.put_if_present("mediaType", media_type)
289 |> Maps.put_if_present("name", data["name"])
290 |> Maps.put_if_present("blurhash", data["blurhash"])
297 Map.put(object, "attachment", attachments)
300 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
302 |> Map.put("attachment", [attachment])
306 def fix_attachments(object), do: object
308 def fix_url(%{"url" => url} = object) when is_map(url) do
309 Map.put(object, "url", url["href"])
312 def fix_url(%{"url" => url} = object) when is_list(url) do
313 first_element = Enum.at(url, 0)
317 is_bitstring(first_element) -> first_element
318 is_map(first_element) -> first_element["href"] || ""
322 Map.put(object, "url", url_string)
325 def fix_url(object), do: object
327 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
330 |> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
331 |> Enum.reduce(%{}, fn data, mapping ->
332 name = String.trim(data["name"], ":")
334 Map.put(mapping, name, data["icon"]["url"])
337 Map.put(object, "emoji", emoji)
340 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
341 name = String.trim(tag["name"], ":")
342 emoji = %{name => tag["icon"]["url"]}
344 Map.put(object, "emoji", emoji)
347 def fix_emoji(object), do: object
349 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
352 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
354 %{"name" => "#" <> hashtag} -> String.downcase(hashtag)
355 %{"name" => hashtag} -> String.downcase(hashtag)
358 Map.put(object, "tag", tag ++ tags)
361 def fix_tag(%{"tag" => %{} = tag} = object) do
363 |> Map.put("tag", [tag])
367 def fix_tag(object), do: object
369 # content map usually only has one language so this will do for now.
370 def fix_content_map(%{"contentMap" => content_map} = object) do
371 content_groups = Map.to_list(content_map)
372 {_, content} = Enum.at(content_groups, 0)
374 Map.put(object, "content", content)
377 def fix_content_map(object), do: object
379 defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
380 when is_binary(reply_id) do
381 options = Keyword.put(options, :fetch, true)
383 with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
384 Map.put(object, "type", "Answer")
390 defp fix_type(object, _options), do: object
392 # Reduce the object list to find the reported user.
393 defp get_reported(objects) do
394 Enum.reduce_while(objects, nil, fn ap_id, _ ->
395 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
403 def handle_incoming(data, options \\ [])
405 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
407 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
408 with context <- data["context"] || Utils.generate_context_id(),
409 content <- data["content"] || "",
410 %User{} = actor <- User.get_cached_by_ap_id(actor),
411 # Reduce the object list to find the reported user.
412 %User{} = account <- get_reported(objects),
413 # Remove the reported user from the object list.
414 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
421 additional: %{"cc" => [account.ap_id]}
423 |> ActivityPub.flag()
427 # disallow objects with bogus IDs
428 def handle_incoming(%{"id" => nil}, _options), do: :error
429 def handle_incoming(%{"id" => ""}, _options), do: :error
430 # length of https:// = 8, should validate better, but good enough for now.
431 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
434 @doc "Rewrite misskey likes into EmojiReacts"
438 "_misskey_reaction" => reaction,
444 |> Map.put("type", "EmojiReact")
445 |> Map.put("content", reaction)
446 |> handle_incoming(options)
452 "_misskey_reaction" => reaction
457 |> Map.put("type", "EmojiReact")
458 |> Map.put("content", reaction)
459 |> handle_incoming(options)
463 %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
466 when objtype in ~w{Question Answer Audio Video Event Article Note Page} do
467 fetch_options = Keyword.put(options, :depth, (options[:depth] || 0) + 1)
471 |> strip_internal_fields()
472 |> fix_type(fetch_options)
473 |> fix_in_reply_to(fetch_options)
474 |> fix_quote_url(fetch_options)
476 data = Map.put(data, "object", object)
477 options = Keyword.put(options, :local, false)
479 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
480 nil <- Activity.get_create_by_object_ap_id(obj_id),
481 {:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
484 %Activity{} = activity -> {:ok, activity}
489 def handle_incoming(%{"type" => type} = data, _options)
490 when type in ~w{Like EmojiReact Announce Add Remove} do
491 with :ok <- ObjectValidator.fetch_actor_and_object(data),
492 {:ok, activity, _meta} <- Pipeline.common_pipeline(data, local: false) do
501 %{"type" => type} = data,
504 when type in ~w{Update Block Follow Accept Reject} do
505 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
506 {:ok, activity, _} <-
507 Pipeline.common_pipeline(data, local: false) do
513 %{"type" => "Delete"} = data,
516 with {:ok, activity, _} <-
517 Pipeline.common_pipeline(data, local: false) do
520 {:error, {:validate, _}} = e ->
521 # Check if we have a create activity for this
522 with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
523 %Activity{data: %{"actor" => actor}} <-
524 Activity.create_by_object_ap_id(object_id) |> Repo.one(),
525 # We have one, insert a tombstone and retry
526 {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
527 {:ok, _tombstone} <- Object.create(tombstone_data) do
528 handle_incoming(data)
538 "object" => %{"type" => "Follow", "object" => followed},
544 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
545 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
546 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
547 User.unfollow(follower, followed)
557 "object" => %{"type" => type}
561 when type in ["Like", "EmojiReact", "Announce", "Block"] do
562 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
567 # For Undos that don't have the complete object attached, try to find it in our database.
575 when is_binary(object) do
576 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
578 |> Map.put("object", data)
579 |> handle_incoming(options)
588 "actor" => origin_actor,
589 "object" => origin_actor,
590 "target" => target_actor
594 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
595 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
596 true <- origin_actor in target_user.also_known_as do
597 ActivityPub.move(origin_user, target_user, false)
603 def handle_incoming(_, _), do: :error
605 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
606 def get_obj_helper(id, options \\ []) do
607 options = Keyword.put(options, :fetch, true)
609 case Object.normalize(id, options) do
610 %Object{} = object -> {:ok, object}
615 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
616 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
619 when attributed_to == ap_id do
620 with {:ok, activity} <-
625 "actor" => attributed_to,
628 {:ok, Object.normalize(activity, fetch: false)}
630 _ -> get_obj_helper(object_id)
634 def get_embedded_obj_helper(object_id, _) do
635 get_obj_helper(object_id)
638 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
639 with false <- String.starts_with?(in_reply_to, "http"),
640 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
641 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
647 def set_reply_to_uri(obj), do: obj
649 def set_quote_url(%{"quoteUri" => quote} = object) when is_binary(quote) do
650 Map.put(object, "quoteUrl", quote)
653 def set_quote_url(obj), do: obj
656 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
657 Based on Mastodon's ActivityPub::NoteSerializer#replies.
659 def set_replies(obj_data) do
661 with limit when limit > 0 <-
662 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
663 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
665 |> Object.self_replies()
666 |> select([o], fragment("?->>'id'", o.data))
673 set_replies(obj_data, replies_uris)
676 defp set_replies(obj, []) do
680 defp set_replies(obj, replies_uris) do
681 replies_collection = %{
682 "type" => "Collection",
683 "items" => replies_uris
686 Map.merge(obj, %{"replies" => replies_collection})
689 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
693 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
697 def replies(_), do: []
699 # Prepares the object of an outgoing create activity.
700 def prepare_object(object) do
706 |> prepare_attachments
711 |> strip_internal_fields
712 |> strip_internal_tags
718 # internal -> Mastodon
721 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
722 when activity_type in ["Create"] do
725 |> Object.normalize(fetch: false)
731 |> Map.put("object", object)
732 |> Map.merge(Utils.make_json_ld_header())
738 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
741 |> Object.normalize(fetch: false)
744 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
745 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
747 data |> maybe_fix_object_url
752 |> strip_internal_fields
753 |> Map.merge(Utils.make_json_ld_header())
759 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
760 # because of course it does.
761 def prepare_outgoing(%{"type" => "Accept"} = data) do
762 with follow_activity <- Activity.normalize(data["object"]) do
764 "actor" => follow_activity.actor,
765 "object" => follow_activity.data["object"],
766 "id" => follow_activity.data["id"],
772 |> Map.put("object", object)
773 |> Map.merge(Utils.make_json_ld_header())
779 def prepare_outgoing(%{"type" => "Reject"} = data) do
780 with follow_activity <- Activity.normalize(data["object"]) do
782 "actor" => follow_activity.actor,
783 "object" => follow_activity.data["object"],
784 "id" => follow_activity.data["id"],
790 |> Map.put("object", object)
791 |> Map.merge(Utils.make_json_ld_header())
797 def prepare_outgoing(%{"type" => _type} = data) do
800 |> strip_internal_fields
801 |> maybe_fix_object_url
802 |> Map.merge(Utils.make_json_ld_header())
807 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
808 with false <- String.starts_with?(object, "http"),
809 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
810 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
812 Map.put(data, "object", external_url)
815 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
823 def maybe_fix_object_url(data), do: data
825 def add_hashtags(object) do
827 (object["tag"] || [])
829 # Expand internal representation tags into AS2 tags.
830 tag when is_binary(tag) ->
832 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
837 # Do not process tags which are already AS2 tag objects.
838 tag when is_map(tag) ->
842 Map.put(object, "tag", tags)
845 # TODO These should be added on our side on insertion, it doesn't make much
846 # sense to regenerate these all the time
847 def add_mention_tags(object) do
848 to = object["to"] || []
849 cc = object["cc"] || []
850 mentioned = User.get_users_from_set(to ++ cc, local_only: false)
852 mentions = Enum.map(mentioned, &build_mention_tag/1)
854 tags = object["tag"] || []
855 Map.put(object, "tag", tags ++ mentions)
858 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
859 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
862 def take_emoji_tags(%User{emoji: emoji}) do
865 |> Enum.map(&build_emoji_tag/1)
868 # TODO: we should probably send mtime instead of unix epoch time for updated
869 def add_emoji_tags(%{"emoji" => emoji} = object) do
870 tags = object["tag"] || []
872 out = Enum.map(emoji, &build_emoji_tag/1)
874 Map.put(object, "tag", tags ++ out)
877 def add_emoji_tags(object), do: object
879 defp build_emoji_tag({name, url}) do
881 "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
882 "name" => ":" <> name <> ":",
884 "updated" => "1970-01-01T00:00:00Z",
889 def set_conversation(object) do
890 Map.put(object, "conversation", object["context"])
893 def set_type(%{"type" => "Answer"} = object) do
894 Map.put(object, "type", "Note")
897 def set_type(object), do: object
899 def add_attributed_to(object) do
900 attributed_to = object["attributedTo"] || object["actor"]
901 Map.put(object, "attributedTo", attributed_to)
904 def prepare_attachments(object) do
907 |> Map.get("attachment", [])
908 |> Enum.map(fn data ->
909 [%{"mediaType" => media_type, "href" => href} = url | _] = data["url"]
913 "mediaType" => media_type,
914 "name" => data["name"],
917 |> Maps.put_if_present("width", url["width"])
918 |> Maps.put_if_present("height", url["height"])
919 |> Maps.put_if_present("blurhash", data["blurhash"])
922 Map.put(object, "attachment", attachments)
925 def strip_internal_fields(object) do
926 Map.drop(object, Pleroma.Constants.object_internal_fields())
929 defp strip_internal_tags(%{"tag" => tags} = object) do
930 tags = Enum.filter(tags, fn x -> is_map(x) end)
932 Map.put(object, "tag", tags)
935 defp strip_internal_tags(object), do: object
937 def perform(:user_upgrade, user) do
938 # we pass a fake user so that the followers collection is stripped away
939 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
943 where: ^old_follower_address in a.recipients,
948 "array_replace(?,?,?)",
950 ^old_follower_address,
951 ^user.follower_address
956 |> Repo.update_all([])
959 def upgrade_user_from_ap_id(ap_id) do
960 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
961 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
962 {:ok, user} <- update_user(user, data) do
963 {:ok, _pid} = Task.start(fn -> ActivityPub.pinned_fetch_task(user) end)
964 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
967 %User{} = user -> {:ok, user}
972 defp update_user(user, data) do
974 |> User.remote_user_changeset(data)
975 |> User.update_and_set_cache()
978 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
979 Map.put(data, "url", url["href"])
982 def maybe_fix_user_url(data), do: data
984 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)