1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 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)
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 def fix_explicit_addressing(
76 %{"to" => to, "cc" => cc} = object,
80 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
82 explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
86 |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
90 |> Map.put("to", explicit_to)
91 |> Map.put("cc", final_cc)
94 def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
96 # if directMessage flag is set to true, leave the addressing alone
97 def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
99 def fix_explicit_addressing(object) do
100 explicit_mentions = Utils.determine_explicit_mentions(object)
102 %User{follower_address: follower_collection} =
104 |> Containment.get_actor()
105 |> User.get_cached_by_ap_id()
110 Pleroma.Constants.as_public(),
114 fix_explicit_addressing(object, explicit_mentions, follower_collection)
117 # if as:Public is addressed, then make sure the followers collection is also addressed
118 # so that the activities will be delivered to local users.
119 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
120 recipients = to ++ cc
122 if followers_collection not in recipients do
124 Pleroma.Constants.as_public() in cc ->
125 to = to ++ [followers_collection]
126 Map.put(object, "to", to)
128 Pleroma.Constants.as_public() in to ->
129 cc = cc ++ [followers_collection]
130 Map.put(object, "cc", cc)
140 def fix_implicit_addressing(object, _), do: object
142 def fix_addressing(object) do
143 {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
144 followers_collection = User.ap_followers(user)
147 |> fix_addressing_list("to")
148 |> fix_addressing_list("cc")
149 |> fix_addressing_list("bto")
150 |> fix_addressing_list("bcc")
151 |> fix_explicit_addressing()
152 |> fix_implicit_addressing(followers_collection)
155 def fix_actor(%{"attributedTo" => actor} = object) do
156 actor = Containment.get_actor(%{"actor" => actor})
158 # TODO: Remove actor field for Objects
160 |> Map.put("actor", actor)
161 |> Map.put("attributedTo", actor)
164 def fix_in_reply_to(object, options \\ [])
166 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
167 when not is_nil(in_reply_to) do
168 in_reply_to_id = prepare_in_reply_to(in_reply_to)
169 depth = (options[:depth] || 0) + 1
171 if Federator.allowed_thread_distance?(depth) do
172 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
173 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
175 |> Map.put("inReplyTo", replied_object.data["id"])
176 |> Map.put("context", replied_object.data["context"] || object["conversation"])
177 |> Map.drop(["conversation", "inReplyToAtomUri"])
180 Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
188 def fix_in_reply_to(object, _options), do: object
190 defp prepare_in_reply_to(in_reply_to) do
192 is_bitstring(in_reply_to) ->
195 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
198 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
199 Enum.at(in_reply_to, 0)
206 def fix_context(object) do
207 context = object["context"] || object["conversation"] || Utils.generate_context_id()
210 |> Map.put("context", context)
211 |> Map.drop(["conversation"])
214 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
216 Enum.map(attachment, fn data ->
219 is_list(data["url"]) -> List.first(data["url"])
220 is_map(data["url"]) -> data["url"]
226 is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
227 MIME.valid?(data["mediaType"]) -> data["mediaType"]
228 MIME.valid?(data["mimeType"]) -> data["mimeType"]
234 is_map(url) && is_binary(url["href"]) -> url["href"]
235 is_binary(data["url"]) -> data["url"]
236 is_binary(data["href"]) -> data["href"]
244 "type" => Map.get(url || %{}, "type", "Link")
246 |> Maps.put_if_present("mediaType", media_type)
249 "url" => [attachment_url],
250 "type" => data["type"] || "Document"
252 |> Maps.put_if_present("mediaType", media_type)
253 |> Maps.put_if_present("name", data["name"])
260 Map.put(object, "attachment", attachments)
263 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
265 |> Map.put("attachment", [attachment])
269 def fix_attachments(object), do: object
271 def fix_url(%{"url" => url} = object) when is_map(url) do
272 Map.put(object, "url", url["href"])
275 def fix_url(%{"url" => url} = object) when is_list(url) do
276 first_element = Enum.at(url, 0)
280 is_bitstring(first_element) -> first_element
281 is_map(first_element) -> first_element["href"] || ""
285 Map.put(object, "url", url_string)
288 def fix_url(object), do: object
290 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
293 |> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
294 |> Enum.reduce(%{}, fn data, mapping ->
295 name = String.trim(data["name"], ":")
297 Map.put(mapping, name, data["icon"]["url"])
300 Map.put(object, "emoji", emoji)
303 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
304 name = String.trim(tag["name"], ":")
305 emoji = %{name => tag["icon"]["url"]}
307 Map.put(object, "emoji", emoji)
310 def fix_emoji(object), do: object
312 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
315 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
316 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
318 Map.put(object, "tag", tag ++ tags)
321 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
322 combined = [tag, String.slice(hashtag, 1..-1)]
324 Map.put(object, "tag", combined)
327 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
329 def fix_tag(object), do: object
331 # content map usually only has one language so this will do for now.
332 def fix_content_map(%{"contentMap" => content_map} = object) do
333 content_groups = Map.to_list(content_map)
334 {_, content} = Enum.at(content_groups, 0)
336 Map.put(object, "content", content)
339 def fix_content_map(object), do: object
341 def fix_type(object, options \\ [])
343 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
344 when is_binary(reply_id) do
345 with true <- Federator.allowed_thread_distance?(options[:depth]),
346 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
347 Map.put(object, "type", "Answer")
353 def fix_type(object, _), do: object
355 # Reduce the object list to find the reported user.
356 defp get_reported(objects) do
357 Enum.reduce_while(objects, nil, fn ap_id, _ ->
358 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
366 # Compatibility wrapper for Mastodon votes
367 defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
368 handle_incoming(data)
371 defp handle_create(%{"object" => object} = data, user) do
376 context: object["context"],
378 published: data["published"],
386 |> ActivityPub.create()
389 def handle_incoming(data, options \\ [])
391 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
393 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
394 with context <- data["context"] || Utils.generate_context_id(),
395 content <- data["content"] || "",
396 %User{} = actor <- User.get_cached_by_ap_id(actor),
397 # Reduce the object list to find the reported user.
398 %User{} = account <- get_reported(objects),
399 # Remove the reported user from the object list.
400 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
407 additional: %{"cc" => [account.ap_id]}
409 |> ActivityPub.flag()
413 # disallow objects with bogus IDs
414 def handle_incoming(%{"id" => nil}, _options), do: :error
415 def handle_incoming(%{"id" => ""}, _options), do: :error
416 # length of https:// = 8, should validate better, but good enough for now.
417 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
420 # TODO: validate those with a Ecto scheme
424 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
427 when objtype in ~w{Note Page} do
428 actor = Containment.get_actor(data)
430 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
431 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
434 |> Map.put("object", fix_object(object, options))
435 |> Map.put("actor", actor)
438 with {:ok, created_activity} <- handle_create(data, user) do
439 reply_depth = (options[:depth] || 0) + 1
441 if Federator.allowed_thread_distance?(reply_depth) do
442 for reply_id <- replies(object) do
443 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
445 "depth" => reply_depth
450 {:ok, created_activity}
453 %Activity{} = activity -> {:ok, activity}
459 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
462 actor = Containment.get_actor(data)
465 Map.put(data, "actor", actor)
468 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
469 reply_depth = (options[:depth] || 0) + 1
470 options = Keyword.put(options, :depth, reply_depth)
471 object = fix_object(object, options)
479 published: data["published"],
480 additional: Map.take(data, ["cc", "id"])
483 ActivityPub.listen(params)
489 @misskey_reactions %{
503 @doc "Rewrite misskey likes into EmojiReacts"
507 "_misskey_reaction" => reaction
512 |> Map.put("type", "EmojiReact")
513 |> Map.put("content", @misskey_reactions[reaction] || reaction)
514 |> handle_incoming(options)
518 %{"type" => "Create", "object" => %{"type" => objtype}} = data,
521 when objtype in ~w{Question Answer ChatMessage Audio Video Event Article} do
522 data = Map.put(data, "object", strip_internal_fields(data["object"]))
524 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
525 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
530 def handle_incoming(%{"type" => type} = data, _options)
531 when type in ~w{Like EmojiReact Announce} do
532 with :ok <- ObjectValidator.fetch_actor_and_object(data),
533 {:ok, activity, _meta} <-
534 Pipeline.common_pipeline(data, local: false) do
542 %{"type" => type} = data,
545 when type in ~w{Update Block Follow Accept Reject} do
546 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
547 {:ok, activity, _} <-
548 Pipeline.common_pipeline(data, local: false) do
554 %{"type" => "Delete"} = data,
557 with {:ok, activity, _} <-
558 Pipeline.common_pipeline(data, local: false) do
561 {:error, {:validate_object, _}} = e ->
562 # Check if we have a create activity for this
563 with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
564 %Activity{data: %{"actor" => actor}} <-
565 Activity.create_by_object_ap_id(object_id) |> Repo.one(),
566 # We have one, insert a tombstone and retry
567 {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
568 {:ok, _tombstone} <- Object.create(tombstone_data) do
569 handle_incoming(data)
579 "object" => %{"type" => "Follow", "object" => followed},
585 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
586 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
587 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
588 User.unfollow(follower, followed)
598 "object" => %{"type" => type}
602 when type in ["Like", "EmojiReact", "Announce", "Block"] do
603 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
608 # For Undos that don't have the complete object attached, try to find it in our database.
616 when is_binary(object) do
617 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
619 |> Map.put("object", data)
620 |> handle_incoming(options)
629 "actor" => origin_actor,
630 "object" => origin_actor,
631 "target" => target_actor
635 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
636 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
637 true <- origin_actor in target_user.also_known_as do
638 ActivityPub.move(origin_user, target_user, false)
644 def handle_incoming(_, _), do: :error
646 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
647 def get_obj_helper(id, options \\ []) do
648 case Object.normalize(id, true, options) do
649 %Object{} = object -> {:ok, object}
654 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
655 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
658 when attributed_to == ap_id do
659 with {:ok, activity} <-
664 "actor" => attributed_to,
667 {:ok, Object.normalize(activity)}
669 _ -> get_obj_helper(object_id)
673 def get_embedded_obj_helper(object_id, _) do
674 get_obj_helper(object_id)
677 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
678 with false <- String.starts_with?(in_reply_to, "http"),
679 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
680 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
686 def set_reply_to_uri(obj), do: obj
689 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
690 Based on Mastodon's ActivityPub::NoteSerializer#replies.
692 def set_replies(obj_data) do
694 with limit when limit > 0 <-
695 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
696 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
698 |> Object.self_replies()
699 |> select([o], fragment("?->>'id'", o.data))
706 set_replies(obj_data, replies_uris)
709 defp set_replies(obj, []) do
713 defp set_replies(obj, replies_uris) do
714 replies_collection = %{
715 "type" => "Collection",
716 "items" => replies_uris
719 Map.merge(obj, %{"replies" => replies_collection})
722 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
726 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
730 def replies(_), do: []
732 # Prepares the object of an outgoing create activity.
733 def prepare_object(object) do
740 |> prepare_attachments
744 |> strip_internal_fields
745 |> strip_internal_tags
751 # internal -> Mastodon
754 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
755 when activity_type in ["Create", "Listen"] do
758 |> Object.normalize()
764 |> Map.put("object", object)
765 |> Map.merge(Utils.make_json_ld_header())
771 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
774 |> Object.normalize()
777 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
778 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
780 data |> maybe_fix_object_url
785 |> strip_internal_fields
786 |> Map.merge(Utils.make_json_ld_header())
792 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
793 # because of course it does.
794 def prepare_outgoing(%{"type" => "Accept"} = data) do
795 with follow_activity <- Activity.normalize(data["object"]) do
797 "actor" => follow_activity.actor,
798 "object" => follow_activity.data["object"],
799 "id" => follow_activity.data["id"],
805 |> Map.put("object", object)
806 |> Map.merge(Utils.make_json_ld_header())
812 def prepare_outgoing(%{"type" => "Reject"} = data) do
813 with follow_activity <- Activity.normalize(data["object"]) do
815 "actor" => follow_activity.actor,
816 "object" => follow_activity.data["object"],
817 "id" => follow_activity.data["id"],
823 |> Map.put("object", object)
824 |> Map.merge(Utils.make_json_ld_header())
830 def prepare_outgoing(%{"type" => _type} = data) do
833 |> strip_internal_fields
834 |> maybe_fix_object_url
835 |> Map.merge(Utils.make_json_ld_header())
840 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
841 with false <- String.starts_with?(object, "http"),
842 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
843 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
845 Map.put(data, "object", external_url)
848 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
856 def maybe_fix_object_url(data), do: data
858 def add_hashtags(object) do
860 (object["tag"] || [])
862 # Expand internal representation tags into AS2 tags.
863 tag when is_binary(tag) ->
865 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
870 # Do not process tags which are already AS2 tag objects.
871 tag when is_map(tag) ->
875 Map.put(object, "tag", tags)
878 # TODO These should be added on our side on insertion, it doesn't make much
879 # sense to regenerate these all the time
880 def add_mention_tags(object) do
881 to = object["to"] || []
882 cc = object["cc"] || []
883 mentioned = User.get_users_from_set(to ++ cc, local_only: false)
885 mentions = Enum.map(mentioned, &build_mention_tag/1)
887 tags = object["tag"] || []
888 Map.put(object, "tag", tags ++ mentions)
891 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
892 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
895 def take_emoji_tags(%User{emoji: emoji}) do
898 |> Enum.map(&build_emoji_tag/1)
901 # TODO: we should probably send mtime instead of unix epoch time for updated
902 def add_emoji_tags(%{"emoji" => emoji} = object) do
903 tags = object["tag"] || []
905 out = Enum.map(emoji, &build_emoji_tag/1)
907 Map.put(object, "tag", tags ++ out)
910 def add_emoji_tags(object), do: object
912 defp build_emoji_tag({name, url}) do
914 "icon" => %{"url" => url, "type" => "Image"},
915 "name" => ":" <> name <> ":",
917 "updated" => "1970-01-01T00:00:00Z",
922 def set_conversation(object) do
923 Map.put(object, "conversation", object["context"])
926 def set_sensitive(%{"sensitive" => true} = object) do
930 def set_sensitive(object) do
931 tags = object["tag"] || []
932 Map.put(object, "sensitive", "nsfw" in tags)
935 def set_type(%{"type" => "Answer"} = object) do
936 Map.put(object, "type", "Note")
939 def set_type(object), do: object
941 def add_attributed_to(object) do
942 attributed_to = object["attributedTo"] || object["actor"]
943 Map.put(object, "attributedTo", attributed_to)
947 def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
949 def prepare_attachments(object) do
952 |> Map.get("attachment", [])
953 |> Enum.map(fn data ->
954 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
958 "mediaType" => media_type,
959 "name" => data["name"],
964 Map.put(object, "attachment", attachments)
967 def strip_internal_fields(object) do
968 Map.drop(object, Pleroma.Constants.object_internal_fields())
971 defp strip_internal_tags(%{"tag" => tags} = object) do
972 tags = Enum.filter(tags, fn x -> is_map(x) end)
974 Map.put(object, "tag", tags)
977 defp strip_internal_tags(object), do: object
979 def perform(:user_upgrade, user) do
980 # we pass a fake user so that the followers collection is stripped away
981 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
985 where: ^old_follower_address in a.recipients,
990 "array_replace(?,?,?)",
992 ^old_follower_address,
993 ^user.follower_address
998 |> Repo.update_all([])
1001 def upgrade_user_from_ap_id(ap_id) do
1002 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1003 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id, force_http: true),
1004 {:ok, user} <- update_user(user, data) do
1005 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1008 %User{} = user -> {:ok, user}
1013 defp update_user(user, data) do
1015 |> User.remote_user_changeset(data)
1016 |> User.update_and_set_cache()
1019 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1020 Map.put(data, "url", url["href"])
1023 def maybe_fix_user_url(data), do: data
1025 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)