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 |> fix_quote_url(options)
207 def fix_quote_url(%{"_misskey_quote" => quote_url} = object, options) do
209 |> Map.put("quoteUri", quote_url)
210 |> fix_quote_url(options)
213 def fix_quote_url(object, _), do: object
215 defp prepare_in_reply_to(in_reply_to) do
217 is_bitstring(in_reply_to) ->
220 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
223 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
224 Enum.at(in_reply_to, 0)
231 def fix_context(object) do
232 context = object["context"] || object["conversation"] || Utils.generate_context_id()
235 |> Map.put("context", context)
236 |> Map.drop(["conversation"])
239 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
241 Enum.map(attachment, fn data ->
244 is_list(data["url"]) -> List.first(data["url"])
245 is_map(data["url"]) -> data["url"]
251 is_map(url) && MIME.extensions(url["mediaType"]) != [] ->
254 is_bitstring(data["mediaType"]) && MIME.extensions(data["mediaType"]) != [] ->
257 is_bitstring(data["mimeType"]) && MIME.extensions(data["mimeType"]) != [] ->
266 is_map(url) && is_binary(url["href"]) -> url["href"]
267 is_binary(data["url"]) -> data["url"]
268 is_binary(data["href"]) -> data["href"]
276 "type" => Map.get(url || %{}, "type", "Link")
278 |> Maps.put_if_present("mediaType", media_type)
279 |> Maps.put_if_present("width", (url || %{})["width"] || data["width"])
280 |> Maps.put_if_present("height", (url || %{})["height"] || data["height"])
283 "url" => [attachment_url],
284 "type" => data["type"] || "Document"
286 |> Maps.put_if_present("mediaType", media_type)
287 |> Maps.put_if_present("name", data["name"])
288 |> Maps.put_if_present("blurhash", data["blurhash"])
295 Map.put(object, "attachment", attachments)
298 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
300 |> Map.put("attachment", [attachment])
304 def fix_attachments(object), do: object
306 def fix_url(%{"url" => url} = object) when is_map(url) do
307 Map.put(object, "url", url["href"])
310 def fix_url(%{"url" => url} = object) when is_list(url) do
311 first_element = Enum.at(url, 0)
315 is_bitstring(first_element) -> first_element
316 is_map(first_element) -> first_element["href"] || ""
320 Map.put(object, "url", url_string)
323 def fix_url(object), do: object
325 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
328 |> Enum.filter(fn data -> is_map(data) and data["type"] == "Emoji" and data["icon"] end)
329 |> Enum.reduce(%{}, fn data, mapping ->
330 name = String.trim(data["name"], ":")
332 Map.put(mapping, name, data["icon"]["url"])
335 Map.put(object, "emoji", emoji)
338 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
339 name = String.trim(tag["name"], ":")
340 emoji = %{name => tag["icon"]["url"]}
342 Map.put(object, "emoji", emoji)
345 def fix_emoji(object), do: object
347 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
350 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
352 %{"name" => "#" <> hashtag} -> String.downcase(hashtag)
353 %{"name" => hashtag} -> String.downcase(hashtag)
356 Map.put(object, "tag", tag ++ tags)
359 def fix_tag(%{"tag" => %{} = tag} = object) do
361 |> Map.put("tag", [tag])
365 def fix_tag(object), do: object
367 # content map usually only has one language so this will do for now.
368 def fix_content_map(%{"contentMap" => content_map} = object) do
369 content_groups = Map.to_list(content_map)
370 {_, content} = Enum.at(content_groups, 0)
372 Map.put(object, "content", content)
375 def fix_content_map(object), do: object
377 defp fix_type(%{"type" => "Note", "inReplyTo" => reply_id, "name" => _} = object, options)
378 when is_binary(reply_id) do
379 options = Keyword.put(options, :fetch, true)
381 with %Object{data: %{"type" => "Question"}} <- Object.normalize(reply_id, options) do
382 Map.put(object, "type", "Answer")
388 defp fix_type(object, _options), do: object
390 # Reduce the object list to find the reported user.
391 defp get_reported(objects) do
392 Enum.reduce_while(objects, nil, fn ap_id, _ ->
393 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
401 def handle_incoming(data, options \\ [])
403 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
405 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
406 with context <- data["context"] || Utils.generate_context_id(),
407 content <- data["content"] || "",
408 %User{} = actor <- User.get_cached_by_ap_id(actor),
409 # Reduce the object list to find the reported user.
410 %User{} = account <- get_reported(objects),
411 # Remove the reported user from the object list.
412 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
419 additional: %{"cc" => [account.ap_id]}
421 |> ActivityPub.flag()
425 # disallow objects with bogus IDs
426 def handle_incoming(%{"id" => nil}, _options), do: :error
427 def handle_incoming(%{"id" => ""}, _options), do: :error
428 # length of https:// = 8, should validate better, but good enough for now.
429 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
432 @doc "Rewrite misskey likes into EmojiReacts"
436 "_misskey_reaction" => reaction,
442 |> Map.put("type", "EmojiReact")
443 |> Map.put("content", reaction)
444 |> handle_incoming(options)
450 "_misskey_reaction" => reaction
455 |> Map.put("type", "EmojiReact")
456 |> Map.put("content", reaction)
457 |> handle_incoming(options)
461 %{"type" => "Create", "object" => %{"type" => objtype, "id" => obj_id}} = data,
464 when objtype in ~w{Question Answer Audio Video Event Article Note Page} do
465 fetch_options = Keyword.put(options, :depth, (options[:depth] || 0) + 1)
469 |> strip_internal_fields()
470 |> fix_type(fetch_options)
471 |> fix_in_reply_to(fetch_options)
472 |> fix_quote_url(fetch_options)
474 data = Map.put(data, "object", object)
475 options = Keyword.put(options, :local, false)
477 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
478 nil <- Activity.get_create_by_object_ap_id(obj_id),
479 {:ok, activity, _} <- Pipeline.common_pipeline(data, options) do
482 %Activity{} = activity -> {:ok, activity}
487 def handle_incoming(%{"type" => type} = data, _options)
488 when type in ~w{Like EmojiReact Announce Add Remove} do
489 with :ok <- ObjectValidator.fetch_actor_and_object(data),
490 {:ok, activity, _meta} <- Pipeline.common_pipeline(data, local: false) do
499 %{"type" => type} = data,
502 when type in ~w{Update Block Follow Accept Reject} do
503 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
504 {:ok, activity, _} <-
505 Pipeline.common_pipeline(data, local: false) do
511 %{"type" => "Delete"} = data,
514 with {:ok, activity, _} <-
515 Pipeline.common_pipeline(data, local: false) do
518 {:error, {:validate, _}} = e ->
519 # Check if we have a create activity for this
520 with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
521 %Activity{data: %{"actor" => actor}} <-
522 Activity.create_by_object_ap_id(object_id) |> Repo.one(),
523 # We have one, insert a tombstone and retry
524 {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
525 {:ok, _tombstone} <- Object.create(tombstone_data) do
526 handle_incoming(data)
536 "object" => %{"type" => "Follow", "object" => followed},
542 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
543 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
544 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
545 User.unfollow(follower, followed)
555 "object" => %{"type" => type}
559 when type in ["Like", "EmojiReact", "Announce", "Block"] do
560 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
565 # For Undos that don't have the complete object attached, try to find it in our database.
573 when is_binary(object) do
574 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
576 |> Map.put("object", data)
577 |> handle_incoming(options)
586 "actor" => origin_actor,
587 "object" => origin_actor,
588 "target" => target_actor
592 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
593 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
594 true <- origin_actor in target_user.also_known_as do
595 ActivityPub.move(origin_user, target_user, false)
601 def handle_incoming(_, _), do: :error
603 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
604 def get_obj_helper(id, options \\ []) do
605 options = Keyword.put(options, :fetch, true)
607 case Object.normalize(id, options) do
608 %Object{} = object -> {:ok, object}
613 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
614 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
617 when attributed_to == ap_id do
618 with {:ok, activity} <-
623 "actor" => attributed_to,
626 {:ok, Object.normalize(activity, fetch: false)}
628 _ -> get_obj_helper(object_id)
632 def get_embedded_obj_helper(object_id, _) do
633 get_obj_helper(object_id)
636 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
637 with false <- String.starts_with?(in_reply_to, "http"),
638 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
639 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
645 def set_reply_to_uri(obj), do: obj
647 def set_quote_url(%{"quoteUri" => quote} = object) when is_binary(quote) do
648 Map.put(object, "quoteUrl", quote)
651 def set_quote_url(obj), do: obj
654 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
655 Based on Mastodon's ActivityPub::NoteSerializer#replies.
657 def set_replies(obj_data) do
659 with limit when limit > 0 <-
660 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
661 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
663 |> Object.self_replies()
664 |> select([o], fragment("?->>'id'", o.data))
671 set_replies(obj_data, replies_uris)
674 defp set_replies(obj, []) do
678 defp set_replies(obj, replies_uris) do
679 replies_collection = %{
680 "type" => "Collection",
681 "items" => replies_uris
684 Map.merge(obj, %{"replies" => replies_collection})
687 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
691 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
695 def replies(_), do: []
697 # Prepares the object of an outgoing create activity.
698 def prepare_object(object) do
704 |> prepare_attachments
709 |> strip_internal_fields
710 |> strip_internal_tags
716 # internal -> Mastodon
719 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
720 when activity_type in ["Create"] do
723 |> Object.normalize(fetch: false)
729 |> Map.put("object", object)
730 |> Map.merge(Utils.make_json_ld_header())
736 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
739 |> Object.normalize(fetch: false)
742 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
743 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
745 data |> maybe_fix_object_url
750 |> strip_internal_fields
751 |> Map.merge(Utils.make_json_ld_header())
757 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
758 # because of course it does.
759 def prepare_outgoing(%{"type" => "Accept"} = data) do
760 with follow_activity <- Activity.normalize(data["object"]) do
762 "actor" => follow_activity.actor,
763 "object" => follow_activity.data["object"],
764 "id" => follow_activity.data["id"],
770 |> Map.put("object", object)
771 |> Map.merge(Utils.make_json_ld_header())
777 def prepare_outgoing(%{"type" => "Reject"} = data) do
778 with follow_activity <- Activity.normalize(data["object"]) do
780 "actor" => follow_activity.actor,
781 "object" => follow_activity.data["object"],
782 "id" => follow_activity.data["id"],
788 |> Map.put("object", object)
789 |> Map.merge(Utils.make_json_ld_header())
795 def prepare_outgoing(%{"type" => _type} = data) do
798 |> strip_internal_fields
799 |> maybe_fix_object_url
800 |> Map.merge(Utils.make_json_ld_header())
805 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
806 with false <- String.starts_with?(object, "http"),
807 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
808 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
810 Map.put(data, "object", external_url)
813 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
821 def maybe_fix_object_url(data), do: data
823 def add_hashtags(object) do
825 (object["tag"] || [])
827 # Expand internal representation tags into AS2 tags.
828 tag when is_binary(tag) ->
830 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
835 # Do not process tags which are already AS2 tag objects.
836 tag when is_map(tag) ->
840 Map.put(object, "tag", tags)
843 # TODO These should be added on our side on insertion, it doesn't make much
844 # sense to regenerate these all the time
845 def add_mention_tags(object) do
846 to = object["to"] || []
847 cc = object["cc"] || []
848 mentioned = User.get_users_from_set(to ++ cc, local_only: false)
850 mentions = Enum.map(mentioned, &build_mention_tag/1)
852 tags = object["tag"] || []
853 Map.put(object, "tag", tags ++ mentions)
856 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
857 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
860 def take_emoji_tags(%User{emoji: emoji}) do
863 |> Enum.map(&build_emoji_tag/1)
866 # TODO: we should probably send mtime instead of unix epoch time for updated
867 def add_emoji_tags(%{"emoji" => emoji} = object) do
868 tags = object["tag"] || []
870 out = Enum.map(emoji, &build_emoji_tag/1)
872 Map.put(object, "tag", tags ++ out)
875 def add_emoji_tags(object), do: object
877 defp build_emoji_tag({name, url}) do
879 "icon" => %{"url" => "#{URI.encode(url)}", "type" => "Image"},
880 "name" => ":" <> name <> ":",
882 "updated" => "1970-01-01T00:00:00Z",
887 def set_conversation(object) do
888 Map.put(object, "conversation", object["context"])
891 def set_type(%{"type" => "Answer"} = object) do
892 Map.put(object, "type", "Note")
895 def set_type(object), do: object
897 def add_attributed_to(object) do
898 attributed_to = object["attributedTo"] || object["actor"]
899 Map.put(object, "attributedTo", attributed_to)
902 def prepare_attachments(object) do
905 |> Map.get("attachment", [])
906 |> Enum.map(fn data ->
907 [%{"mediaType" => media_type, "href" => href} = url | _] = data["url"]
911 "mediaType" => media_type,
912 "name" => data["name"],
915 |> Maps.put_if_present("width", url["width"])
916 |> Maps.put_if_present("height", url["height"])
917 |> Maps.put_if_present("blurhash", data["blurhash"])
920 Map.put(object, "attachment", attachments)
923 def strip_internal_fields(object) do
924 Map.drop(object, Pleroma.Constants.object_internal_fields())
927 defp strip_internal_tags(%{"tag" => tags} = object) do
928 tags = Enum.filter(tags, fn x -> is_map(x) end)
930 Map.put(object, "tag", tags)
933 defp strip_internal_tags(object), do: object
935 def perform(:user_upgrade, user) do
936 # we pass a fake user so that the followers collection is stripped away
937 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
941 where: ^old_follower_address in a.recipients,
946 "array_replace(?,?,?)",
948 ^old_follower_address,
949 ^user.follower_address
954 |> Repo.update_all([])
957 def upgrade_user_from_ap_id(ap_id) do
958 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
959 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
960 {:ok, user} <- update_user(user, data) do
961 {:ok, _pid} = Task.start(fn -> ActivityPub.pinned_fetch_task(user) end)
962 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
965 %User{} = user -> {:ok, user}
970 defp update_user(user, data) do
972 |> User.remote_user_changeset(data)
973 |> User.update_and_set_cache()
976 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
977 Map.put(data, "url", url["href"])
980 def maybe_fix_user_url(data), do: data
982 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)