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.FollowingRelationship
12 alias Pleroma.Notification
14 alias Pleroma.Object.Containment
17 alias Pleroma.Web.ActivityPub.ActivityPub
18 alias Pleroma.Web.ActivityPub.Builder
19 alias Pleroma.Web.ActivityPub.ObjectValidator
20 alias Pleroma.Web.ActivityPub.ObjectValidators.Types
21 alias Pleroma.Web.ActivityPub.Pipeline
22 alias Pleroma.Web.ActivityPub.Utils
23 alias Pleroma.Web.ActivityPub.Visibility
24 alias Pleroma.Web.Federator
25 alias Pleroma.Workers.TransmogrifierWorker
30 require Pleroma.Constants
33 Modifies an incoming AP object (mastodon format) to our internal format.
35 def fix_object(object, options \\ []) do
37 |> strip_internal_fields
42 |> fix_in_reply_to(options)
52 def fix_summary(%{"summary" => nil} = object) do
53 Map.put(object, "summary", "")
56 def fix_summary(%{"summary" => _} = object) do
57 # summary is present, nothing to do
61 def fix_summary(object), do: Map.put(object, "summary", "")
63 def fix_addressing_list(map, field) do
65 is_binary(map[field]) ->
66 Map.put(map, field, [map[field]])
69 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 Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
160 def fix_in_reply_to(object, options \\ [])
162 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
163 when not is_nil(in_reply_to) do
164 in_reply_to_id = prepare_in_reply_to(in_reply_to)
165 object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
166 depth = (options[:depth] || 0) + 1
168 if Federator.allowed_thread_distance?(depth) do
169 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
170 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
172 |> Map.put("inReplyTo", replied_object.data["id"])
173 |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
174 |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
175 |> Map.put("context", replied_object.data["context"] || object["conversation"])
178 Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
186 def fix_in_reply_to(object, _options), do: object
188 defp prepare_in_reply_to(in_reply_to) do
190 is_bitstring(in_reply_to) ->
193 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
196 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
197 Enum.at(in_reply_to, 0)
204 def fix_context(object) do
205 context = object["context"] || object["conversation"] || Utils.generate_context_id()
208 |> Map.put("context", context)
209 |> Map.put("conversation", context)
212 defp add_if_present(map, _key, nil), do: map
214 defp add_if_present(map, key, value) do
215 Map.put(map, key, value)
218 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
220 Enum.map(attachment, fn data ->
223 is_list(data["url"]) -> List.first(data["url"])
224 is_map(data["url"]) -> data["url"]
230 is_map(url) && is_binary(url["mediaType"]) -> url["mediaType"]
231 is_binary(data["mediaType"]) -> data["mediaType"]
232 is_binary(data["mimeType"]) -> data["mimeType"]
238 is_map(url) && is_binary(url["href"]) -> url["href"]
239 is_binary(data["url"]) -> data["url"]
240 is_binary(data["href"]) -> data["href"]
245 |> add_if_present("mediaType", media_type)
246 |> add_if_present("type", Map.get(url || %{}, "type"))
248 %{"url" => [attachment_url]}
249 |> add_if_present("mediaType", media_type)
250 |> add_if_present("type", data["type"])
251 |> add_if_present("name", data["name"])
254 Map.put(object, "attachment", attachments)
257 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
259 |> Map.put("attachment", [attachment])
263 def fix_attachments(object), do: object
265 def fix_url(%{"url" => url} = object) when is_map(url) do
266 Map.put(object, "url", url["href"])
269 def fix_url(%{"type" => object_type, "url" => url} = object)
270 when object_type in ["Video", "Audio"] and is_list(url) do
271 first_element = Enum.at(url, 0)
273 link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
276 |> Map.put("attachment", [first_element])
277 |> Map.put("url", link_element["href"])
280 def fix_url(%{"type" => object_type, "url" => url} = object)
281 when object_type != "Video" and is_list(url) do
282 first_element = Enum.at(url, 0)
286 is_bitstring(first_element) -> first_element
287 is_map(first_element) -> first_element["href"] || ""
291 Map.put(object, "url", url_string)
294 def fix_url(object), do: object
296 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
299 |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
300 |> Enum.reduce(%{}, fn data, mapping ->
301 name = String.trim(data["name"], ":")
303 Map.put(mapping, name, data["icon"]["url"])
306 # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
307 emoji = Map.merge(object["emoji"] || %{}, emoji)
309 Map.put(object, "emoji", emoji)
312 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
313 name = String.trim(tag["name"], ":")
314 emoji = %{name => tag["icon"]["url"]}
316 Map.put(object, "emoji", emoji)
319 def fix_emoji(object), do: object
321 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
324 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
325 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
327 Map.put(object, "tag", tag ++ tags)
330 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
331 combined = [tag, String.slice(hashtag, 1..-1)]
333 Map.put(object, "tag", combined)
336 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
338 def fix_tag(object), do: object
340 # content map usually only has one language so this will do for now.
341 def fix_content_map(%{"contentMap" => content_map} = object) do
342 content_groups = Map.to_list(content_map)
343 {_, content} = Enum.at(content_groups, 0)
345 Map.put(object, "content", content)
348 def fix_content_map(object), do: object
350 def fix_type(object, options \\ [])
352 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
353 when is_binary(reply_id) do
354 with true <- Federator.allowed_thread_distance?(options[:depth]),
355 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
356 Map.put(object, "type", "Answer")
362 def fix_type(object, _), do: object
364 defp fix_content(%{"mediaType" => "text/markdown", "content" => content} = object)
365 when is_binary(content) do
368 |> Earmark.as_html!(%Earmark.Options{renderer: EarmarkRenderer})
369 |> Pleroma.HTML.filter_tags()
371 Map.merge(object, %{"content" => html_content, "mediaType" => "text/html"})
374 defp fix_content(object), do: object
376 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
377 with true <- id =~ "follows",
378 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
379 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
386 defp mastodon_follow_hack(_, _), do: {:error, nil}
388 defp get_follow_activity(follow_object, followed) do
389 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
390 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
393 # Can't find the activity. This might a Mastodon 2.3 "Accept"
395 mastodon_follow_hack(follow_object, followed)
402 # Reduce the object list to find the reported user.
403 defp get_reported(objects) do
404 Enum.reduce_while(objects, nil, fn ap_id, _ ->
405 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
413 def handle_incoming(data, options \\ [])
415 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
417 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
418 with context <- data["context"] || Utils.generate_context_id(),
419 content <- data["content"] || "",
420 %User{} = actor <- User.get_cached_by_ap_id(actor),
421 # Reduce the object list to find the reported user.
422 %User{} = account <- get_reported(objects),
423 # Remove the reported user from the object list.
424 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
431 additional: %{"cc" => [account.ap_id]}
433 |> ActivityPub.flag()
437 # disallow objects with bogus IDs
438 def handle_incoming(%{"id" => nil}, _options), do: :error
439 def handle_incoming(%{"id" => ""}, _options), do: :error
440 # length of https:// = 8, should validate better, but good enough for now.
441 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
444 # TODO: validate those with a Ecto scheme
448 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
451 when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
452 actor = Containment.get_actor(data)
455 Map.put(data, "actor", actor)
458 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
459 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
460 object = fix_object(object, options)
466 context: object["conversation"],
468 published: data["published"],
477 with {:ok, created_activity} <- ActivityPub.create(params) do
478 reply_depth = (options[:depth] || 0) + 1
480 if Federator.allowed_thread_distance?(reply_depth) do
481 for reply_id <- replies(object) do
482 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
484 "depth" => reply_depth
489 {:ok, created_activity}
492 %Activity{} = activity -> {:ok, activity}
498 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
501 actor = Containment.get_actor(data)
504 Map.put(data, "actor", actor)
507 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
508 reply_depth = (options[:depth] || 0) + 1
509 options = Keyword.put(options, :depth, reply_depth)
510 object = fix_object(object, options)
518 published: data["published"],
519 additional: Map.take(data, ["cc", "id"])
522 ActivityPub.listen(params)
529 %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
532 with %User{local: true} = followed <-
533 User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
534 {:ok, %User{} = follower} <-
535 User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
536 {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
537 with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
538 {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
539 {_, false} <- {:user_locked, User.locked?(followed)},
540 {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
542 {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
543 {:ok, _relationship} <-
544 FollowingRelationship.update(follower, followed, :follow_accept) do
545 ActivityPub.accept(%{
546 to: [follower.ap_id],
552 {:user_blocked, true} ->
553 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
554 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
556 ActivityPub.reject(%{
557 to: [follower.ap_id],
563 {:follow, {:error, _}} ->
564 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
565 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
567 ActivityPub.reject(%{
568 to: [follower.ap_id],
574 {:user_locked, true} ->
575 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_pending)
587 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
590 with actor <- Containment.get_actor(data),
591 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
592 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
593 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
594 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
595 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
596 User.update_follower_count(followed)
597 User.update_following_count(follower)
599 Notification.update_notification_type(followed, follow_activity)
601 ActivityPub.accept(%{
602 to: follow_activity.data["to"],
605 object: follow_activity.data["id"],
616 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
619 with actor <- Containment.get_actor(data),
620 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
621 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
622 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
623 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
624 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
626 ActivityPub.reject(%{
627 to: follow_activity.data["to"],
630 object: follow_activity.data["id"],
640 @misskey_reactions %{
654 @doc "Rewrite misskey likes into EmojiReacts"
658 "_misskey_reaction" => reaction
663 |> Map.put("type", "EmojiReact")
664 |> Map.put("content", @misskey_reactions[reaction] || reaction)
665 |> handle_incoming(options)
669 %{"type" => "Create", "object" => %{"type" => "ChatMessage"}} = data,
672 with {:ok, %User{}} <- ObjectValidator.fetch_actor(data),
673 {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
678 def handle_incoming(%{"type" => type} = data, _options)
679 when type in ["Like", "EmojiReact", "Announce"] do
680 with :ok <- ObjectValidator.fetch_actor_and_object(data),
681 {:ok, activity, _meta} <-
682 Pipeline.common_pipeline(data, local: false) do
690 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
694 when object_type in [
700 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
701 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
704 |> User.remote_user_changeset(new_user_data)
705 |> User.update_and_set_cache()
707 ActivityPub.update(%{
709 to: data["to"] || [],
710 cc: data["cc"] || [],
713 activity_id: data["id"]
723 %{"type" => "Delete"} = data,
726 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
729 {:error, {:validate_object, _}} = e ->
730 # Check if we have a create activity for this
731 with {:ok, object_id} <- Types.ObjectID.cast(data["object"]),
732 %Activity{data: %{"actor" => actor}} <-
733 Activity.create_by_object_ap_id(object_id) |> Repo.one(),
734 # We have one, insert a tombstone and retry
735 {:ok, tombstone_data, _} <- Builder.tombstone(actor, object_id),
736 {:ok, _tombstone} <- Object.create(tombstone_data) do
737 handle_incoming(data)
747 "object" => %{"type" => "Follow", "object" => followed},
753 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
754 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
755 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
756 User.unfollow(follower, followed)
766 "object" => %{"type" => type}
770 when type in ["Like", "EmojiReact", "Announce", "Block"] do
771 with {:ok, activity, _} <- Pipeline.common_pipeline(data, local: false) do
776 # For Undos that don't have the complete object attached, try to find it in our database.
784 when is_binary(object) do
785 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
787 |> Map.put("object", data)
788 |> handle_incoming(options)
795 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
798 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
799 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
800 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
801 User.unfollow(blocker, blocked)
802 User.block(blocker, blocked)
812 "actor" => origin_actor,
813 "object" => origin_actor,
814 "target" => target_actor
818 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
819 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
820 true <- origin_actor in target_user.also_known_as do
821 ActivityPub.move(origin_user, target_user, false)
827 def handle_incoming(_, _), do: :error
829 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
830 def get_obj_helper(id, options \\ []) do
831 case Object.normalize(id, true, options) do
832 %Object{} = object -> {:ok, object}
837 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
838 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
841 when attributed_to == ap_id do
842 with {:ok, activity} <-
847 "actor" => attributed_to,
850 {:ok, Object.normalize(activity)}
852 _ -> get_obj_helper(object_id)
856 def get_embedded_obj_helper(object_id, _) do
857 get_obj_helper(object_id)
860 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
861 with false <- String.starts_with?(in_reply_to, "http"),
862 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
863 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
869 def set_reply_to_uri(obj), do: obj
872 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
873 Based on Mastodon's ActivityPub::NoteSerializer#replies.
875 def set_replies(obj_data) do
877 with limit when limit > 0 <-
878 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
879 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
881 |> Object.self_replies()
882 |> select([o], fragment("?->>'id'", o.data))
889 set_replies(obj_data, replies_uris)
892 defp set_replies(obj, []) do
896 defp set_replies(obj, replies_uris) do
897 replies_collection = %{
898 "type" => "Collection",
899 "items" => replies_uris
902 Map.merge(obj, %{"replies" => replies_collection})
905 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
909 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
913 def replies(_), do: []
915 # Prepares the object of an outgoing create activity.
916 def prepare_object(object) do
923 |> prepare_attachments
927 |> strip_internal_fields
928 |> strip_internal_tags
934 # internal -> Mastodon
937 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
938 when activity_type in ["Create", "Listen"] do
941 |> Object.normalize()
947 |> Map.put("object", object)
948 |> Map.merge(Utils.make_json_ld_header())
954 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
957 |> Object.normalize()
960 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
961 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
963 data |> maybe_fix_object_url
968 |> strip_internal_fields
969 |> Map.merge(Utils.make_json_ld_header())
975 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
976 # because of course it does.
977 def prepare_outgoing(%{"type" => "Accept"} = data) do
978 with follow_activity <- Activity.normalize(data["object"]) do
980 "actor" => follow_activity.actor,
981 "object" => follow_activity.data["object"],
982 "id" => follow_activity.data["id"],
988 |> Map.put("object", object)
989 |> Map.merge(Utils.make_json_ld_header())
995 def prepare_outgoing(%{"type" => "Reject"} = data) do
996 with follow_activity <- Activity.normalize(data["object"]) do
998 "actor" => follow_activity.actor,
999 "object" => follow_activity.data["object"],
1000 "id" => follow_activity.data["id"],
1006 |> Map.put("object", object)
1007 |> Map.merge(Utils.make_json_ld_header())
1013 def prepare_outgoing(%{"type" => _type} = data) do
1016 |> strip_internal_fields
1017 |> maybe_fix_object_url
1018 |> Map.merge(Utils.make_json_ld_header())
1023 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1024 with false <- String.starts_with?(object, "http"),
1025 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1026 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1028 Map.put(data, "object", external_url)
1031 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1039 def maybe_fix_object_url(data), do: data
1041 def add_hashtags(object) do
1043 (object["tag"] || [])
1045 # Expand internal representation tags into AS2 tags.
1046 tag when is_binary(tag) ->
1048 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1049 "name" => "##{tag}",
1053 # Do not process tags which are already AS2 tag objects.
1054 tag when is_map(tag) ->
1058 Map.put(object, "tag", tags)
1061 # TODO These should be added on our side on insertion, it doesn't make much
1062 # sense to regenerate these all the time
1063 def add_mention_tags(object) do
1064 to = object["to"] || []
1065 cc = object["cc"] || []
1066 mentioned = User.get_users_from_set(to ++ cc, local_only: false)
1068 mentions = Enum.map(mentioned, &build_mention_tag/1)
1070 tags = object["tag"] || []
1071 Map.put(object, "tag", tags ++ mentions)
1074 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1075 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1078 def take_emoji_tags(%User{emoji: emoji}) do
1081 |> Enum.map(&build_emoji_tag/1)
1084 # TODO: we should probably send mtime instead of unix epoch time for updated
1085 def add_emoji_tags(%{"emoji" => emoji} = object) do
1086 tags = object["tag"] || []
1088 out = Enum.map(emoji, &build_emoji_tag/1)
1090 Map.put(object, "tag", tags ++ out)
1093 def add_emoji_tags(object), do: object
1095 defp build_emoji_tag({name, url}) do
1097 "icon" => %{"url" => url, "type" => "Image"},
1098 "name" => ":" <> name <> ":",
1100 "updated" => "1970-01-01T00:00:00Z",
1105 def set_conversation(object) do
1106 Map.put(object, "conversation", object["context"])
1109 def set_sensitive(%{"sensitive" => true} = object) do
1113 def set_sensitive(object) do
1114 tags = object["tag"] || []
1115 Map.put(object, "sensitive", "nsfw" in tags)
1118 def set_type(%{"type" => "Answer"} = object) do
1119 Map.put(object, "type", "Note")
1122 def set_type(object), do: object
1124 def add_attributed_to(object) do
1125 attributed_to = object["attributedTo"] || object["actor"]
1126 Map.put(object, "attributedTo", attributed_to)
1129 # TODO: Revisit this
1130 def prepare_attachments(%{"type" => "ChatMessage"} = object), do: object
1132 def prepare_attachments(object) do
1135 |> Map.get("attachment", [])
1136 |> Enum.map(fn data ->
1137 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1141 "mediaType" => media_type,
1142 "name" => data["name"],
1143 "type" => "Document"
1147 Map.put(object, "attachment", attachments)
1150 def strip_internal_fields(object) do
1151 Map.drop(object, Pleroma.Constants.object_internal_fields())
1154 defp strip_internal_tags(%{"tag" => tags} = object) do
1155 tags = Enum.filter(tags, fn x -> is_map(x) end)
1157 Map.put(object, "tag", tags)
1160 defp strip_internal_tags(object), do: object
1162 def perform(:user_upgrade, user) do
1163 # we pass a fake user so that the followers collection is stripped away
1164 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1168 where: ^old_follower_address in a.recipients,
1173 "array_replace(?,?,?)",
1175 ^old_follower_address,
1176 ^user.follower_address
1181 |> Repo.update_all([])
1184 def upgrade_user_from_ap_id(ap_id) do
1185 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1186 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1187 {:ok, user} <- update_user(user, data) do
1188 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1191 %User{} = user -> {:ok, user}
1196 defp update_user(user, data) do
1198 |> User.remote_user_changeset(data)
1199 |> User.update_and_set_cache()
1202 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1203 Map.put(data, "url", url["href"])
1206 def maybe_fix_user_url(data), do: data
1208 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)