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.EarmarkRenderer
11 alias Pleroma.EctoType.ActivityPub.ObjectValidators
12 alias Pleroma.FollowingRelationship
14 alias Pleroma.Notification
16 alias Pleroma.Object.Containment
19 alias Pleroma.Web.ActivityPub.ActivityPub
20 alias Pleroma.Web.ActivityPub.Builder
21 alias Pleroma.Web.ActivityPub.ObjectValidator
22 alias Pleroma.Web.ActivityPub.Pipeline
23 alias Pleroma.Web.ActivityPub.Utils
24 alias Pleroma.Web.ActivityPub.Visibility
25 alias Pleroma.Web.Federator
26 alias Pleroma.Workers.TransmogrifierWorker
31 require Pleroma.Constants
34 Modifies an incoming AP object (mastodon format) to our internal format.
36 def fix_object(object, options \\ []) do
38 |> strip_internal_fields
43 |> fix_in_reply_to(options)
53 def fix_summary(%{"summary" => nil} = object) do
54 Map.put(object, "summary", "")
57 def fix_summary(%{"summary" => _} = object) do
58 # summary is present, nothing to do
62 def fix_summary(object), do: Map.put(object, "summary", "")
64 def fix_addressing_list(map, field) do
69 Map.put(map, field, Enum.filter(addrs, &is_binary/1))
72 Map.put(map, field, [addrs])
75 Map.put(map, field, [])
79 def fix_explicit_addressing(
80 %{"to" => to, "cc" => cc} = object,
84 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
86 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 def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
100 # if directMessage flag is set to true, leave the addressing alone
101 def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
103 def fix_explicit_addressing(object) do
104 explicit_mentions = Utils.determine_explicit_mentions(object)
106 %User{follower_address: follower_collection} =
108 |> Containment.get_actor()
109 |> User.get_cached_by_ap_id()
114 Pleroma.Constants.as_public(),
118 fix_explicit_addressing(object, explicit_mentions, follower_collection)
121 # if as:Public is addressed, then make sure the followers collection is also addressed
122 # so that the activities will be delivered to local users.
123 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
124 recipients = to ++ cc
126 if followers_collection not in recipients do
128 Pleroma.Constants.as_public() in cc ->
129 to = to ++ [followers_collection]
130 Map.put(object, "to", to)
132 Pleroma.Constants.as_public() in to ->
133 cc = cc ++ [followers_collection]
134 Map.put(object, "cc", cc)
144 def fix_implicit_addressing(object, _), do: object
146 def fix_addressing(object) do
147 {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
148 followers_collection = User.ap_followers(user)
151 |> fix_addressing_list("to")
152 |> fix_addressing_list("cc")
153 |> fix_addressing_list("bto")
154 |> fix_addressing_list("bcc")
155 |> fix_explicit_addressing()
156 |> fix_implicit_addressing(followers_collection)
159 def fix_actor(%{"attributedTo" => actor} = object) do
160 actor = Containment.get_actor(%{"actor" => actor})
162 # TODO: Remove actor field for Objects
164 |> Map.put("actor", actor)
165 |> Map.put("attributedTo", actor)
168 def fix_in_reply_to(object, options \\ [])
170 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
171 when not is_nil(in_reply_to) do
172 in_reply_to_id = prepare_in_reply_to(in_reply_to)
173 object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
174 depth = (options[:depth] || 0) + 1
176 if Federator.allowed_thread_distance?(depth) do
177 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
178 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
180 |> Map.put("inReplyTo", replied_object.data["id"])
181 |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
182 |> Map.put("context", replied_object.data["context"] || object["conversation"])
183 |> Map.drop(["conversation"])
186 Logger.warn("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
194 def fix_in_reply_to(object, _options), do: object
196 defp prepare_in_reply_to(in_reply_to) do
198 is_bitstring(in_reply_to) ->
201 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
204 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
205 Enum.at(in_reply_to, 0)
212 def fix_context(object) do
213 context = object["context"] || object["conversation"] || Utils.generate_context_id()
216 |> Map.put("context", context)
217 |> Map.drop(["conversation"])
220 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
222 Enum.map(attachment, fn data ->
225 is_list(data["url"]) -> List.first(data["url"])
226 is_map(data["url"]) -> data["url"]
232 is_map(url) && MIME.valid?(url["mediaType"]) -> url["mediaType"]
233 MIME.valid?(data["mediaType"]) -> data["mediaType"]
234 MIME.valid?(data["mimeType"]) -> data["mimeType"]
240 is_map(url) && is_binary(url["href"]) -> url["href"]
241 is_binary(data["url"]) -> data["url"]
242 is_binary(data["href"]) -> data["href"]
250 "type" => Map.get(url || %{}, "type", "Link")
252 |> Maps.put_if_present("mediaType", media_type)
255 "url" => [attachment_url],
256 "type" => data["type"] || "Document"
258 |> Maps.put_if_present("mediaType", media_type)
259 |> Maps.put_if_present("name", data["name"])
266 Map.put(object, "attachment", attachments)
269 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
271 |> Map.put("attachment", [attachment])
275 def fix_attachments(object), do: object
277 def fix_url(%{"url" => url} = object) when is_map(url) do
278 Map.put(object, "url", url["href"])
281 def fix_url(%{"type" => object_type, "url" => url} = object)
282 when object_type in ["Video", "Audio"] and is_list(url) do
284 Enum.find(url, fn x ->
285 media_type = x["mediaType"] || x["mimeType"] || ""
287 is_map(x) and String.starts_with?(media_type, ["audio/", "video/"])
291 Enum.find(url, fn x -> is_map(x) and (x["mediaType"] || x["mimeType"]) == "text/html" end)
294 |> Map.put("attachment", [attachment])
295 |> Map.put("url", link_element["href"])
298 def fix_url(%{"type" => object_type, "url" => url} = object)
299 when object_type != "Video" and is_list(url) do
300 first_element = Enum.at(url, 0)
304 is_bitstring(first_element) -> first_element
305 is_map(first_element) -> first_element["href"] || ""
309 Map.put(object, "url", url_string)
312 def fix_url(object), do: object
314 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
317 |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
318 |> Enum.reduce(%{}, fn data, mapping ->
319 name = String.trim(data["name"], ":")
321 Map.put(mapping, name, data["icon"]["url"])
324 # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
325 emoji = Map.merge(object["emoji"] || %{}, emoji)
327 Map.put(object, "emoji", emoji)
330 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
331 name = String.trim(tag["name"], ":")
332 emoji = %{name => tag["icon"]["url"]}
334 Map.put(object, "emoji", emoji)
337 def fix_emoji(object), do: object
339 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
342 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
343 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
345 Map.put(object, "tag", tag ++ tags)
348 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
349 combined = [tag, String.slice(hashtag, 1..-1)]
351 Map.put(object, "tag", combined)
354 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
356 def fix_tag(object), do: object
358 # content map usually only has one language so this will do for now.
359 def fix_content_map(%{"contentMap" => content_map} = object) do
360 content_groups = Map.to_list(content_map)
361 {_, content} = Enum.at(content_groups, 0)
363 Map.put(object, "content", content)
366 def fix_content_map(object), do: object
368 def fix_type(object, options \\ [])
370 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
371 when is_binary(reply_id) do
372 with true <- Federator.allowed_thread_distance?(options[:depth]),
373 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
374 Map.put(object, "type", "Answer")
380 def fix_type(object, _), do: object
382 defp fix_content(%{"mediaType" => "text/markdown", "content" => content} = object)
383 when is_binary(content) do
386 |> Earmark.as_html!(%Earmark.Options{renderer: EarmarkRenderer})
387 |> Pleroma.HTML.filter_tags()
389 Map.merge(object, %{"content" => html_content, "mediaType" => "text/html"})
392 defp fix_content(object), do: object
394 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
395 with true <- id =~ "follows",
396 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
397 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
404 defp mastodon_follow_hack(_, _), do: {:error, nil}
406 defp get_follow_activity(follow_object, followed) do
407 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
408 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
411 # Can't find the activity. This might a Mastodon 2.3 "Accept"
413 mastodon_follow_hack(follow_object, followed)
420 # Reduce the object list to find the reported user.
421 defp get_reported(objects) do
422 Enum.reduce_while(objects, nil, fn ap_id, _ ->
423 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
431 # Compatibility wrapper for Mastodon votes
432 defp handle_create(%{"object" => %{"type" => "Answer"}} = data, _user) do
433 handle_incoming(data)
436 defp handle_create(%{"object" => object} = data, user) do
441 context: object["context"],
443 published: data["published"],
451 |> ActivityPub.create()
454 def handle_incoming(data, options \\ [])
456 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
458 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
459 with context <- data["context"] || Utils.generate_context_id(),
460 content <- data["content"] || "",
461 %User{} = actor <- User.get_cached_by_ap_id(actor),
462 # Reduce the object list to find the reported user.
463 %User{} = account <- get_reported(objects),
464 # Remove the reported user from the object list.
465 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
472 additional: %{"cc" => [account.ap_id]}
474 |> ActivityPub.flag()
478 # disallow objects with bogus IDs
479 def handle_incoming(%{"id" => nil}, _options), do: :error
480 def handle_incoming(%{"id" => ""}, _options), do: :error
481 # length of https:// = 8, should validate better, but good enough for now.
482 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
485 # TODO: validate those with a Ecto scheme
489 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
492 when objtype in ["Article", "Event", "Note", "Video", "Page", "Audio"] do
493 actor = Containment.get_actor(data)
495 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
496 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(actor) do
499 |> Map.put("object", fix_object(object, options))
500 |> Map.put("actor", actor)
503 with {:ok, created_activity} <- handle_create(data, user) do
504 reply_depth = (options[:depth] || 0) + 1
506 if Federator.allowed_thread_distance?(reply_depth) do
507 for reply_id <- replies(object) do
508 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
510 "depth" => reply_depth
515 {:ok, created_activity}
518 %Activity{} = activity -> {:ok, activity}
524 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
527 actor = Containment.get_actor(data)
530 Map.put(data, "actor", actor)
533 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
534 reply_depth = (options[:depth] || 0) + 1
535 options = Keyword.put(options, :depth, reply_depth)
536 object = fix_object(object, options)
544 published: data["published"],
545 additional: Map.take(data, ["cc", "id"])
548 ActivityPub.listen(params)
555 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
558 with actor <- Containment.get_actor(data),
559 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
560 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
561 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
562 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
563 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
564 User.update_follower_count(followed)
565 User.update_following_count(follower)
567 Notification.update_notification_type(followed, follow_activity)
569 ActivityPub.accept(%{
570 to: follow_activity.data["to"],
573 object: follow_activity.data["id"],
584 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
587 with actor <- Containment.get_actor(data),
588 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
589 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
590 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
591 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
592 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
594 ActivityPub.reject(%{
595 to: follow_activity.data["to"],
598 object: follow_activity.data["id"],
608 @misskey_reactions %{
622 @doc "Rewrite misskey likes into EmojiReacts"
626 "_misskey_reaction" => reaction
631 |> Map.put("type", "EmojiReact")
632 |> Map.put("content", @misskey_reactions[reaction] || reaction)
633 |> handle_incoming(options)
637 %{"type" => "Create", "object" => %{"type" => objtype}} = data,
640 when objtype in ["Question", "Answer", "ChatMessage"] do
641 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
642 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
648 %{"type" => "Create", "object" => %{"type" => "ChatMessage"}} = data,
651 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
652 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
657 def handle_incoming(%{"type" => type} = data, _options)
658 when type in ~w{Like EmojiReact Announce} do
659 with :ok <- ObjectValidator.fetch_actor_and_object(data),
660 {:ok, activity, _meta} <-
661 Pipeline.common_pipeline(data, local: false) do
669 %{"type" => type} = data,
672 when type in ~w{Update Block Follow} do
673 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
674 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
680 %{"type" => "Delete"} = data,
683 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
686 {:error, {:validate_object, _}} = e ->
687 # Check if we have a create activity for this
688 with {:ok, object_id} <- ObjectValidators.ObjectID.cast(data["object"]),
689 %Activity{data: %{"actor" => actor}} <-
690 Activity.create_by_object_ap_id(object_id) |> Repo.one(),
691 # We have one, insert a tombstone and retry
692 {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
693 {:ok, _tombstone} <- Object.create(tombstone_data) do
694 handle_incoming(data)
704 "object" => %{"type" => "Follow", "object" => followed},
710 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
711 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
712 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
713 User.unfollow(follower, followed)
723 "object" => %{"type" => type}
727 when type in ["Like", "EmojiReact", "Announce", "Block"] do
728 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
733 # For Undos that don't have the complete object attached, try to find it in our database.
741 when is_binary(object) do
742 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
744 |> Map.put("object", data)
745 |> handle_incoming(options)
754 "actor" => origin_actor,
755 "object" => origin_actor,
756 "target" => target_actor
760 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
761 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
762 true <- origin_actor in target_user.also_known_as do
763 ActivityPub.move(origin_user, target_user, false)
769 def handle_incoming(_, _), do: :error
771 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
772 def get_obj_helper(id, options \\ []) do
773 case Object.normalize(id, true, options) do
774 %Object{} = object -> {:ok, object}
779 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
780 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
783 when attributed_to == ap_id do
784 with {:ok, activity} <-
789 "actor" => attributed_to,
792 {:ok, Object.normalize(activity)}
794 _ -> get_obj_helper(object_id)
798 def get_embedded_obj_helper(object_id, _) do
799 get_obj_helper(object_id)
802 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
803 with false <- String.starts_with?(in_reply_to, "http"),
804 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
805 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
811 def set_reply_to_uri(obj), do: obj
814 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
815 Based on Mastodon's ActivityPub::NoteSerializer#replies.
817 def set_replies(obj_data) do
819 with limit when limit > 0 <-
820 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
821 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
823 |> Object.self_replies()
824 |> select([o], fragment("?->>'id'", o.data))
831 set_replies(obj_data, replies_uris)
834 defp set_replies(obj, []) do
838 defp set_replies(obj, replies_uris) do
839 replies_collection = %{
840 "type" => "Collection",
841 "items" => replies_uris
844 Map.merge(obj, %{"replies" => replies_collection})
847 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
851 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
855 def replies(_), do: []
857 # Prepares the object of an outgoing create activity.
858 def prepare_object(object) do
865 |> prepare_attachments
869 |> strip_internal_fields
870 |> strip_internal_tags
876 # internal -> Mastodon
879 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
880 when activity_type in ["Create", "Listen"] do
883 |> Object.normalize()
889 |> Map.put("object", object)
890 |> Map.merge(Utils.make_json_ld_header())
896 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
899 |> Object.normalize()
902 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
903 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
905 data |> maybe_fix_object_url
910 |> strip_internal_fields
911 |> Map.merge(Utils.make_json_ld_header())
917 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
918 # because of course it does.
919 def prepare_outgoing(%{"type" => "Accept"} = data) do
920 with follow_activity <- Activity.normalize(data["object"]) do
922 "actor" => follow_activity.actor,
923 "object" => follow_activity.data["object"],
924 "id" => follow_activity.data["id"],
930 |> Map.put("object", object)
931 |> Map.merge(Utils.make_json_ld_header())
937 def prepare_outgoing(%{"type" => "Reject"} = data) do
938 with follow_activity <- Activity.normalize(data["object"]) do
940 "actor" => follow_activity.actor,
941 "object" => follow_activity.data["object"],
942 "id" => follow_activity.data["id"],
948 |> Map.put("object", object)
949 |> Map.merge(Utils.make_json_ld_header())
955 def prepare_outgoing(%{"type" => _type} = data) do
958 |> strip_internal_fields
959 |> maybe_fix_object_url
960 |> Map.merge(Utils.make_json_ld_header())
965 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
966 with false <- String.starts_with?(object, "http"),
967 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
968 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
970 Map.put(data, "object", external_url)
973 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
981 def maybe_fix_object_url(data), do: data
983 def add_hashtags(object) do
985 (object["tag"] || [])
987 # Expand internal representation tags into AS2 tags.
988 tag when is_binary(tag) ->
990 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
995 # Do not process tags which are already AS2 tag objects.
996 tag when is_map(tag) ->
1000 Map.put(object, "tag", tags)
1003 # TODO These should be added on our side on insertion, it doesn't make much
1004 # sense to regenerate these all the time
1005 def add_mention_tags(object) do
1006 to = object["to"] || []
1007 cc = object["cc"] || []
1008 mentioned = User.get_users_from_set(to ++ cc, local_only: false)
1010 mentions = Enum.map(mentioned, &build_mention_tag/1)
1012 tags = object["tag"] || []
1013 Map.put(object, "tag", tags ++ mentions)
1016 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1017 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1020 def take_emoji_tags(%User{emoji: emoji}) do
1023 |> Enum.map(&build_emoji_tag/1)
1026 # TODO: we should probably send mtime instead of unix epoch time for updated
1027 def add_emoji_tags(%{"emoji" => emoji} = object) do
1028 tags = object["tag"] || []
1030 out = Enum.map(emoji, &build_emoji_tag/1)
1032 Map.put(object, "tag", tags ++ out)
1035 def add_emoji_tags(object), do: object
1037 defp build_emoji_tag({name, url}) do
1039 "icon" => %{"url" => url, "type" => "Image"},
1040 "name" => ":" <> name <> ":",
1042 "updated" => "1970-01-01T00:00:00Z",
1047 def set_conversation(object) do
1048 Map.put(object, "conversation", object["context"])
1051 def set_sensitive(%{"sensitive" => true} = object) do
1055 def set_sensitive(object) do
1056 tags = object["tag"] || []
1057 Map.put(object, "sensitive", "nsfw" in tags)
1060 def set_type(%{"type" => "Answer"} = object) do
1061 Map.put(object, "type", "Note")
1064 def set_type(object), do: object
1066 def add_attributed_to(object) do
1067 attributed_to = object["attributedTo"] || object["actor"]
1068 Map.put(object, "attributedTo", attributed_to)
1071 # TODO: Revisit this
1072 def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
1074 def prepare_attachments(object) do
1077 |> Map.get("attachment", [])
1078 |> Enum.map(fn data ->
1079 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1083 "mediaType" => media_type,
1084 "name" => data["name"],
1085 "type" => "Document"
1089 Map.put(object, "attachment", attachments)
1092 def strip_internal_fields(object) do
1093 Map.drop(object, Pleroma.Constants.object_internal_fields())
1096 defp strip_internal_tags(%{"tag" => tags} = object) do
1097 tags = Enum.filter(tags, fn x -> is_map(x) end)
1099 Map.put(object, "tag", tags)
1102 defp strip_internal_tags(object), do: object
1104 def perform(:user_upgrade, user) do
1105 # we pass a fake user so that the followers collection is stripped away
1106 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1110 where: ^old_follower_address in a.recipients,
1115 "array_replace(?,?,?)",
1117 ^old_follower_address,
1118 ^user.follower_address
1123 |> Repo.update_all([])
1126 def upgrade_user_from_ap_id(ap_id) do
1127 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1128 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1129 {:ok, user} <- update_user(user, data) do
1130 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1133 %User{} = user -> {:ok, user}
1138 defp update_user(user, data) do
1140 |> User.remote_user_changeset(data)
1141 |> User.update_and_set_cache()
1144 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1145 Map.put(data, "url", url["href"])
1148 def maybe_fix_user_url(data), do: data
1150 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)