1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 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.FollowingRelationship
12 alias Pleroma.Object.Containment
15 alias Pleroma.Web.ActivityPub.ActivityPub
16 alias Pleroma.Web.ActivityPub.Utils
17 alias Pleroma.Web.ActivityPub.Visibility
18 alias Pleroma.Web.Federator
19 alias Pleroma.Workers.TransmogrifierWorker
24 require Pleroma.Constants
27 Modifies an incoming AP object (mastodon format) to our internal format.
29 def fix_object(object, options \\ []) do
31 |> strip_internal_fields
36 |> fix_in_reply_to(options)
45 def fix_summary(%{"summary" => nil} = object) do
46 Map.put(object, "summary", "")
49 def fix_summary(%{"summary" => _} = object) do
50 # summary is present, nothing to do
54 def fix_summary(object), do: Map.put(object, "summary", "")
56 def fix_addressing_list(map, field) do
58 is_binary(map[field]) ->
59 Map.put(map, field, [map[field]])
62 Map.put(map, field, [])
69 def fix_explicit_addressing(
70 %{"to" => to, "cc" => cc} = object,
74 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
76 explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
80 |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
84 |> Map.put("to", explicit_to)
85 |> Map.put("cc", final_cc)
88 def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
90 # if directMessage flag is set to true, leave the addressing alone
91 def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
93 def fix_explicit_addressing(object) do
94 explicit_mentions = Utils.determine_explicit_mentions(object)
96 %User{follower_address: follower_collection} =
98 |> Containment.get_actor()
99 |> User.get_cached_by_ap_id()
104 Pleroma.Constants.as_public(),
108 fix_explicit_addressing(object, explicit_mentions, follower_collection)
111 # if as:Public is addressed, then make sure the followers collection is also addressed
112 # so that the activities will be delivered to local users.
113 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
114 recipients = to ++ cc
116 if followers_collection not in recipients do
118 Pleroma.Constants.as_public() in cc ->
119 to = to ++ [followers_collection]
120 Map.put(object, "to", to)
122 Pleroma.Constants.as_public() in to ->
123 cc = cc ++ [followers_collection]
124 Map.put(object, "cc", cc)
134 def fix_implicit_addressing(object, _), do: object
136 def fix_addressing(object) do
137 {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
138 followers_collection = User.ap_followers(user)
141 |> fix_addressing_list("to")
142 |> fix_addressing_list("cc")
143 |> fix_addressing_list("bto")
144 |> fix_addressing_list("bcc")
145 |> fix_explicit_addressing()
146 |> fix_implicit_addressing(followers_collection)
149 def fix_actor(%{"attributedTo" => actor} = object) do
150 Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
153 def fix_in_reply_to(object, options \\ [])
155 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
156 when not is_nil(in_reply_to) do
157 in_reply_to_id = prepare_in_reply_to(in_reply_to)
158 object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
160 if Federator.allowed_incoming_reply_depth?(options[:depth]) do
161 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
162 %Activity{} = _ <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
164 |> Map.put("inReplyTo", replied_object.data["id"])
165 |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
166 |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
167 |> Map.put("context", replied_object.data["context"] || object["conversation"])
170 Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
178 def fix_in_reply_to(object, _options), do: object
180 defp prepare_in_reply_to(in_reply_to) do
182 is_bitstring(in_reply_to) ->
185 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
188 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
189 Enum.at(in_reply_to, 0)
196 def fix_context(object) do
197 context = object["context"] || object["conversation"] || Utils.generate_context_id()
200 |> Map.put("context", context)
201 |> Map.put("conversation", context)
204 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
206 Enum.map(attachment, fn data ->
207 media_type = data["mediaType"] || data["mimeType"]
208 href = data["url"] || data["href"]
209 url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]
212 |> Map.put("mediaType", media_type)
213 |> Map.put("url", url)
216 Map.put(object, "attachment", attachments)
219 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
221 |> Map.put("attachment", [attachment])
225 def fix_attachments(object), do: object
227 def fix_url(%{"url" => url} = object) when is_map(url) do
228 Map.put(object, "url", url["href"])
231 def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
232 first_element = Enum.at(url, 0)
234 link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
237 |> Map.put("attachment", [first_element])
238 |> Map.put("url", link_element["href"])
241 def fix_url(%{"type" => object_type, "url" => url} = object)
242 when object_type != "Video" and is_list(url) do
243 first_element = Enum.at(url, 0)
247 is_bitstring(first_element) -> first_element
248 is_map(first_element) -> first_element["href"] || ""
252 Map.put(object, "url", url_string)
255 def fix_url(object), do: object
257 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
260 |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
261 |> Enum.reduce(%{}, fn data, mapping ->
262 name = String.trim(data["name"], ":")
264 Map.put(mapping, name, data["icon"]["url"])
267 # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
268 emoji = Map.merge(object["emoji"] || %{}, emoji)
270 Map.put(object, "emoji", emoji)
273 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
274 name = String.trim(tag["name"], ":")
275 emoji = %{name => tag["icon"]["url"]}
277 Map.put(object, "emoji", emoji)
280 def fix_emoji(object), do: object
282 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
285 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
286 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
288 Map.put(object, "tag", tag ++ tags)
291 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
292 combined = [tag, String.slice(hashtag, 1..-1)]
294 Map.put(object, "tag", combined)
297 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
299 def fix_tag(object), do: object
301 # content map usually only has one language so this will do for now.
302 def fix_content_map(%{"contentMap" => content_map} = object) do
303 content_groups = Map.to_list(content_map)
304 {_, content} = Enum.at(content_groups, 0)
306 Map.put(object, "content", content)
309 def fix_content_map(object), do: object
311 def fix_type(object, options \\ [])
313 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
314 when is_binary(reply_id) do
315 with true <- Federator.allowed_incoming_reply_depth?(options[:depth]),
316 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
317 Map.put(object, "type", "Answer")
323 def fix_type(object, _), do: object
325 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
326 with true <- id =~ "follows",
327 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
328 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
335 defp mastodon_follow_hack(_, _), do: {:error, nil}
337 defp get_follow_activity(follow_object, followed) do
338 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
339 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
342 # Can't find the activity. This might a Mastodon 2.3 "Accept"
344 mastodon_follow_hack(follow_object, followed)
351 # Reduce the object list to find the reported user.
352 defp get_reported(objects) do
353 Enum.reduce_while(objects, nil, fn ap_id, _ ->
354 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
362 def handle_incoming(data, options \\ [])
364 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
366 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
367 with context <- data["context"] || Utils.generate_context_id(),
368 content <- data["content"] || "",
369 %User{} = actor <- User.get_cached_by_ap_id(actor),
370 # Reduce the object list to find the reported user.
371 %User{} = account <- get_reported(objects),
372 # Remove the reported user from the object list.
373 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
380 additional: %{"cc" => [account.ap_id]}
382 |> ActivityPub.flag()
386 # disallow objects with bogus IDs
387 def handle_incoming(%{"id" => nil}, _options), do: :error
388 def handle_incoming(%{"id" => ""}, _options), do: :error
389 # length of https:// = 8, should validate better, but good enough for now.
390 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
393 # TODO: validate those with a Ecto scheme
397 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
400 when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer"] do
401 actor = Containment.get_actor(data)
404 Map.put(data, "actor", actor)
407 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
408 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
409 options = Keyword.put(options, :depth, (options[:depth] || 0) + 1)
410 object = fix_object(object, options)
416 context: object["conversation"],
418 published: data["published"],
427 with {:ok, created_activity} <- ActivityPub.create(params) do
428 for reply_id <- replies(object) do
429 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{"id" => reply_id})
432 {:ok, created_activity}
435 %Activity{} = activity -> {:ok, activity}
441 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
444 actor = Containment.get_actor(data)
447 Map.put(data, "actor", actor)
450 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
451 options = Keyword.put(options, :depth, (options[:depth] || 0) + 1)
452 object = fix_object(object, options)
460 published: data["published"],
461 additional: Map.take(data, ["cc", "id"])
464 ActivityPub.listen(params)
471 %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
474 with %User{local: true} = followed <-
475 User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
476 {:ok, %User{} = follower} <-
477 User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
478 {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
479 with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
480 {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
481 {_, false} <- {:user_locked, User.locked?(followed)},
482 {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
484 {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
485 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
486 ActivityPub.accept(%{
487 to: [follower.ap_id],
493 {:user_blocked, true} ->
494 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
495 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
497 ActivityPub.reject(%{
498 to: [follower.ap_id],
504 {:follow, {:error, _}} ->
505 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
506 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
508 ActivityPub.reject(%{
509 to: [follower.ap_id],
515 {:user_locked, true} ->
516 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "pending")
528 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
531 with actor <- Containment.get_actor(data),
532 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
533 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
534 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
535 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
536 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
537 ActivityPub.accept(%{
538 to: follow_activity.data["to"],
541 object: follow_activity.data["id"],
551 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
554 with actor <- Containment.get_actor(data),
555 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
556 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
557 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
558 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
559 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"),
561 ActivityPub.reject(%{
562 to: follow_activity.data["to"],
565 object: follow_activity.data["id"],
575 @misskey_reactions %{
589 @doc "Rewrite misskey likes into EmojiReacts"
593 "_misskey_reaction" => reaction
598 |> Map.put("type", "EmojiReact")
599 |> Map.put("content", @misskey_reactions[reaction] || reaction)
600 |> handle_incoming(options)
604 %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
607 with actor <- Containment.get_actor(data),
608 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
609 {:ok, object} <- get_obj_helper(object_id),
610 {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
619 "type" => "EmojiReact",
620 "object" => object_id,
627 with actor <- Containment.get_actor(data),
628 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
629 {:ok, object} <- get_obj_helper(object_id),
630 {:ok, activity, _object} <-
631 ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
639 %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
642 with actor <- Containment.get_actor(data),
643 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
644 {:ok, object} <- get_embedded_obj_helper(object_id, actor),
645 public <- Visibility.is_public?(data),
646 {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
654 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
658 when object_type in [
664 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
665 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
668 |> User.upgrade_changeset(new_user_data, true)
669 |> User.update_and_set_cache()
671 ActivityPub.update(%{
673 to: data["to"] || [],
674 cc: data["cc"] || [],
677 activity_id: data["id"]
686 # TODO: We presently assume that any actor on the same origin domain as the object being
687 # deleted has the rights to delete that object. A better way to validate whether or not
688 # the object should be deleted is to refetch the object URI, which should return either
689 # an error or a tombstone. This would allow us to verify that a deletion actually took
692 %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
695 object_id = Utils.get_ap_id(object_id)
697 with actor <- Containment.get_actor(data),
698 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
699 {:ok, object} <- get_obj_helper(object_id),
700 :ok <- Containment.contain_origin(actor.ap_id, object.data),
702 ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
706 case User.get_cached_by_ap_id(object_id) do
707 %User{ap_id: ^actor} = user ->
722 "object" => %{"type" => "Announce", "object" => object_id},
728 with actor <- Containment.get_actor(data),
729 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
730 {:ok, object} <- get_obj_helper(object_id),
731 {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
741 "object" => %{"type" => "Follow", "object" => followed},
747 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
748 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
749 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
750 User.unfollow(follower, followed)
760 "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
766 with actor <- Containment.get_actor(data),
767 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
768 {:ok, activity, _} <-
769 ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
782 "object" => %{"type" => "Block", "object" => blocked},
788 with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
789 {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
790 {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
791 User.unblock(blocker, blocked)
799 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
802 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
803 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
804 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
805 User.unfollow(blocker, blocked)
806 User.block(blocker, blocked)
816 "object" => %{"type" => "Like", "object" => object_id},
822 with actor <- Containment.get_actor(data),
823 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
824 {:ok, object} <- get_obj_helper(object_id),
825 {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
832 # For Undos that don't have the complete object attached, try to find it in our database.
840 when is_binary(object) do
841 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
843 |> Map.put("object", data)
844 |> handle_incoming(options)
853 "actor" => origin_actor,
854 "object" => origin_actor,
855 "target" => target_actor
859 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
860 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
861 true <- origin_actor in target_user.also_known_as do
862 ActivityPub.move(origin_user, target_user, false)
868 def handle_incoming(_, _), do: :error
870 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
871 def get_obj_helper(id, options \\ []) do
872 case Object.normalize(id, true, options) do
873 %Object{} = object -> {:ok, object}
878 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
879 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
882 when attributed_to == ap_id do
883 with {:ok, activity} <-
888 "actor" => attributed_to,
891 {:ok, Object.normalize(activity)}
893 _ -> get_obj_helper(object_id)
897 def get_embedded_obj_helper(object_id, _) do
898 get_obj_helper(object_id)
901 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
902 with false <- String.starts_with?(in_reply_to, "http"),
903 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
904 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
910 def set_reply_to_uri(obj), do: obj
913 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
914 Based on Mastodon's ActivityPub::NoteSerializer#replies.
916 def set_replies(obj_data) do
918 with limit when limit > 0 <-
919 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
920 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
922 |> Object.self_replies()
923 |> select([o], fragment("?->>'id'", o.data))
930 set_replies(obj_data, replies_uris)
933 defp set_replies(obj, []) do
937 defp set_replies(obj, replies_uris) do
938 replies_collection = %{
939 "type" => "Collection",
940 "items" => replies_uris
943 Map.merge(obj, %{"replies" => replies_collection})
946 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
950 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
954 def replies(_), do: []
956 # Prepares the object of an outgoing create activity.
957 def prepare_object(object) do
964 |> prepare_attachments
968 |> strip_internal_fields
969 |> strip_internal_tags
975 # internal -> Mastodon
978 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
979 when activity_type in ["Create", "Listen"] do
982 |> Object.normalize()
988 |> Map.put("object", object)
989 |> Map.merge(Utils.make_json_ld_header())
995 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
998 |> Object.normalize()
1001 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1002 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1004 data |> maybe_fix_object_url
1009 |> strip_internal_fields
1010 |> Map.merge(Utils.make_json_ld_header())
1011 |> Map.delete("bcc")
1016 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1017 # because of course it does.
1018 def prepare_outgoing(%{"type" => "Accept"} = data) do
1019 with follow_activity <- Activity.normalize(data["object"]) do
1021 "actor" => follow_activity.actor,
1022 "object" => follow_activity.data["object"],
1023 "id" => follow_activity.data["id"],
1029 |> Map.put("object", object)
1030 |> Map.merge(Utils.make_json_ld_header())
1036 def prepare_outgoing(%{"type" => "Reject"} = data) do
1037 with follow_activity <- Activity.normalize(data["object"]) do
1039 "actor" => follow_activity.actor,
1040 "object" => follow_activity.data["object"],
1041 "id" => follow_activity.data["id"],
1047 |> Map.put("object", object)
1048 |> Map.merge(Utils.make_json_ld_header())
1054 def prepare_outgoing(%{"type" => _type} = data) do
1057 |> strip_internal_fields
1058 |> maybe_fix_object_url
1059 |> Map.merge(Utils.make_json_ld_header())
1064 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1065 with false <- String.starts_with?(object, "http"),
1066 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1067 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1069 Map.put(data, "object", external_url)
1072 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1080 def maybe_fix_object_url(data), do: data
1082 def add_hashtags(object) do
1084 (object["tag"] || [])
1086 # Expand internal representation tags into AS2 tags.
1087 tag when is_binary(tag) ->
1089 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1090 "name" => "##{tag}",
1094 # Do not process tags which are already AS2 tag objects.
1095 tag when is_map(tag) ->
1099 Map.put(object, "tag", tags)
1102 def add_mention_tags(object) do
1105 |> Utils.get_notified_from_object()
1106 |> Enum.map(&build_mention_tag/1)
1108 tags = object["tag"] || []
1110 Map.put(object, "tag", tags ++ mentions)
1113 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1114 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1117 def take_emoji_tags(%User{emoji: emoji}) do
1119 |> Enum.flat_map(&Map.to_list/1)
1120 |> Enum.map(&build_emoji_tag/1)
1123 # TODO: we should probably send mtime instead of unix epoch time for updated
1124 def add_emoji_tags(%{"emoji" => emoji} = object) do
1125 tags = object["tag"] || []
1127 out = Enum.map(emoji, &build_emoji_tag/1)
1129 Map.put(object, "tag", tags ++ out)
1132 def add_emoji_tags(object), do: object
1134 defp build_emoji_tag({name, url}) do
1136 "icon" => %{"url" => url, "type" => "Image"},
1137 "name" => ":" <> name <> ":",
1139 "updated" => "1970-01-01T00:00:00Z",
1144 def set_conversation(object) do
1145 Map.put(object, "conversation", object["context"])
1148 def set_sensitive(object) do
1149 tags = object["tag"] || []
1150 Map.put(object, "sensitive", "nsfw" in tags)
1153 def set_type(%{"type" => "Answer"} = object) do
1154 Map.put(object, "type", "Note")
1157 def set_type(object), do: object
1159 def add_attributed_to(object) do
1160 attributed_to = object["attributedTo"] || object["actor"]
1161 Map.put(object, "attributedTo", attributed_to)
1164 def prepare_attachments(object) do
1166 (object["attachment"] || [])
1167 |> Enum.map(fn data ->
1168 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1169 %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1172 Map.put(object, "attachment", attachments)
1175 def strip_internal_fields(object) do
1177 |> Map.drop(Pleroma.Constants.object_internal_fields())
1180 defp strip_internal_tags(%{"tag" => tags} = object) do
1181 tags = Enum.filter(tags, fn x -> is_map(x) end)
1183 Map.put(object, "tag", tags)
1186 defp strip_internal_tags(object), do: object
1188 def perform(:user_upgrade, user) do
1189 # we pass a fake user so that the followers collection is stripped away
1190 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1194 where: ^old_follower_address in a.recipients,
1199 "array_replace(?,?,?)",
1201 ^old_follower_address,
1202 ^user.follower_address
1207 |> Repo.update_all([])
1210 def upgrade_user_from_ap_id(ap_id) do
1211 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1212 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1213 already_ap <- User.ap_enabled?(user),
1214 {:ok, user} <- upgrade_user(user, data) do
1215 if not already_ap do
1216 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1221 %User{} = user -> {:ok, user}
1226 defp upgrade_user(user, data) do
1228 |> User.upgrade_changeset(data, true)
1229 |> User.update_and_set_cache()
1232 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1233 Map.put(data, "url", url["href"])
1236 def maybe_fix_user_url(data), do: data
1238 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)