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.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)
159 depth = (options[:depth] || 0) + 1
161 if Federator.allowed_thread_distance?(depth) do
162 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
163 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
165 |> Map.put("inReplyTo", replied_object.data["id"])
166 |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
167 |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
168 |> Map.put("context", replied_object.data["context"] || object["conversation"])
171 Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
179 def fix_in_reply_to(object, _options), do: object
181 defp prepare_in_reply_to(in_reply_to) do
183 is_bitstring(in_reply_to) ->
186 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
189 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
190 Enum.at(in_reply_to, 0)
197 def fix_context(object) do
198 context = object["context"] || object["conversation"] || Utils.generate_context_id()
201 |> Map.put("context", context)
202 |> Map.put("conversation", context)
205 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
207 Enum.map(attachment, fn data ->
208 media_type = data["mediaType"] || data["mimeType"]
209 href = data["url"] || data["href"]
210 url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]
213 |> Map.put("mediaType", media_type)
214 |> Map.put("url", url)
217 Map.put(object, "attachment", attachments)
220 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
222 |> Map.put("attachment", [attachment])
226 def fix_attachments(object), do: object
228 def fix_url(%{"url" => url} = object) when is_map(url) do
229 Map.put(object, "url", url["href"])
232 def fix_url(%{"type" => object_type, "url" => url} = object)
233 when object_type in ["Video", "Audio"] and is_list(url) do
234 first_element = Enum.at(url, 0)
236 link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
239 |> Map.put("attachment", [first_element])
240 |> Map.put("url", link_element["href"])
243 def fix_url(%{"type" => object_type, "url" => url} = object)
244 when object_type != "Video" and is_list(url) do
245 first_element = Enum.at(url, 0)
249 is_bitstring(first_element) -> first_element
250 is_map(first_element) -> first_element["href"] || ""
254 Map.put(object, "url", url_string)
257 def fix_url(object), do: object
259 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
262 |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
263 |> Enum.reduce(%{}, fn data, mapping ->
264 name = String.trim(data["name"], ":")
266 Map.put(mapping, name, data["icon"]["url"])
269 # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
270 emoji = Map.merge(object["emoji"] || %{}, emoji)
272 Map.put(object, "emoji", emoji)
275 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
276 name = String.trim(tag["name"], ":")
277 emoji = %{name => tag["icon"]["url"]}
279 Map.put(object, "emoji", emoji)
282 def fix_emoji(object), do: object
284 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
287 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
288 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
290 Map.put(object, "tag", tag ++ tags)
293 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
294 combined = [tag, String.slice(hashtag, 1..-1)]
296 Map.put(object, "tag", combined)
299 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
301 def fix_tag(object), do: object
303 # content map usually only has one language so this will do for now.
304 def fix_content_map(%{"contentMap" => content_map} = object) do
305 content_groups = Map.to_list(content_map)
306 {_, content} = Enum.at(content_groups, 0)
308 Map.put(object, "content", content)
311 def fix_content_map(object), do: object
313 def fix_type(object, options \\ [])
315 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
316 when is_binary(reply_id) do
317 with true <- Federator.allowed_thread_distance?(options[:depth]),
318 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
319 Map.put(object, "type", "Answer")
325 def fix_type(object, _), do: object
327 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
328 with true <- id =~ "follows",
329 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
330 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
337 defp mastodon_follow_hack(_, _), do: {:error, nil}
339 defp get_follow_activity(follow_object, followed) do
340 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
341 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
344 # Can't find the activity. This might a Mastodon 2.3 "Accept"
346 mastodon_follow_hack(follow_object, followed)
353 # Reduce the object list to find the reported user.
354 defp get_reported(objects) do
355 Enum.reduce_while(objects, nil, fn ap_id, _ ->
356 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
364 def handle_incoming(data, options \\ [])
366 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
368 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
369 with context <- data["context"] || Utils.generate_context_id(),
370 content <- data["content"] || "",
371 %User{} = actor <- User.get_cached_by_ap_id(actor),
372 # Reduce the object list to find the reported user.
373 %User{} = account <- get_reported(objects),
374 # Remove the reported user from the object list.
375 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
382 additional: %{"cc" => [account.ap_id]}
384 |> ActivityPub.flag()
388 # disallow objects with bogus IDs
389 def handle_incoming(%{"id" => nil}, _options), do: :error
390 def handle_incoming(%{"id" => ""}, _options), do: :error
391 # length of https:// = 8, should validate better, but good enough for now.
392 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
395 # TODO: validate those with a Ecto scheme
399 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
402 when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
403 actor = Containment.get_actor(data)
406 Map.put(data, "actor", actor)
409 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
410 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
411 object = fix_object(object, options)
417 context: object["conversation"],
419 published: data["published"],
428 with {:ok, created_activity} <- ActivityPub.create(params) do
429 reply_depth = (options[:depth] || 0) + 1
431 if Federator.allowed_thread_distance?(reply_depth) do
432 for reply_id <- replies(object) do
433 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
435 "depth" => reply_depth
440 {:ok, created_activity}
443 %Activity{} = activity -> {:ok, activity}
449 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
452 actor = Containment.get_actor(data)
455 Map.put(data, "actor", actor)
458 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
459 reply_depth = (options[:depth] || 0) + 1
460 options = Keyword.put(options, :depth, reply_depth)
461 object = fix_object(object, options)
469 published: data["published"],
470 additional: Map.take(data, ["cc", "id"])
473 ActivityPub.listen(params)
480 %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
483 with %User{local: true} = followed <-
484 User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
485 {:ok, %User{} = follower} <-
486 User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
487 {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
488 with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
489 {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
490 {_, false} <- {:user_locked, User.locked?(followed)},
491 {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
493 {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
494 {:ok, _relationship} <-
495 FollowingRelationship.update(follower, followed, :follow_accept) do
496 ActivityPub.accept(%{
497 to: [follower.ap_id],
503 {:user_blocked, true} ->
504 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
505 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
507 ActivityPub.reject(%{
508 to: [follower.ap_id],
514 {:follow, {:error, _}} ->
515 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
516 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject)
518 ActivityPub.reject(%{
519 to: [follower.ap_id],
525 {:user_locked, true} ->
526 {:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_pending)
538 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
541 with actor <- Containment.get_actor(data),
542 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
543 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
544 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
545 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
546 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
547 User.update_follower_count(followed)
548 User.update_following_count(follower)
550 ActivityPub.accept(%{
551 to: follow_activity.data["to"],
554 object: follow_activity.data["id"],
565 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
568 with actor <- Containment.get_actor(data),
569 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
570 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
571 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
572 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
573 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject),
575 ActivityPub.reject(%{
576 to: follow_activity.data["to"],
579 object: follow_activity.data["id"],
589 @misskey_reactions %{
603 @doc "Rewrite misskey likes into EmojiReacts"
607 "_misskey_reaction" => reaction
612 |> Map.put("type", "EmojiReact")
613 |> Map.put("content", @misskey_reactions[reaction] || reaction)
614 |> handle_incoming(options)
618 %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
621 with actor <- Containment.get_actor(data),
622 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
623 {:ok, object} <- get_obj_helper(object_id),
624 {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
633 "type" => "EmojiReact",
634 "object" => object_id,
641 with actor <- Containment.get_actor(data),
642 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
643 {:ok, object} <- get_obj_helper(object_id),
644 {:ok, activity, _object} <-
645 ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
653 %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
656 with actor <- Containment.get_actor(data),
657 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
658 {:ok, object} <- get_embedded_obj_helper(object_id, actor),
659 public <- Visibility.is_public?(data),
660 {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
668 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
672 when object_type in [
678 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
679 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
682 |> User.upgrade_changeset(new_user_data, true)
683 |> User.update_and_set_cache()
685 ActivityPub.update(%{
687 to: data["to"] || [],
688 cc: data["cc"] || [],
691 activity_id: data["id"]
700 # TODO: We presently assume that any actor on the same origin domain as the object being
701 # deleted has the rights to delete that object. A better way to validate whether or not
702 # the object should be deleted is to refetch the object URI, which should return either
703 # an error or a tombstone. This would allow us to verify that a deletion actually took
706 %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
709 object_id = Utils.get_ap_id(object_id)
711 with actor <- Containment.get_actor(data),
712 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
713 {:ok, object} <- get_obj_helper(object_id),
714 :ok <- Containment.contain_origin(actor.ap_id, object.data),
716 ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
720 case User.get_cached_by_ap_id(object_id) do
721 %User{ap_id: ^actor} = user ->
736 "object" => %{"type" => "Announce", "object" => object_id},
742 with actor <- Containment.get_actor(data),
743 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
744 {:ok, object} <- get_obj_helper(object_id),
745 {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
755 "object" => %{"type" => "Follow", "object" => followed},
761 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
762 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
763 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
764 User.unfollow(follower, followed)
774 "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
780 with actor <- Containment.get_actor(data),
781 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
782 {:ok, activity, _} <-
783 ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
796 "object" => %{"type" => "Block", "object" => blocked},
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.unblock(blocker, blocked, id, false) do
805 User.unblock(blocker, blocked)
813 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
816 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
817 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
818 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
819 User.unfollow(blocker, blocked)
820 User.block(blocker, blocked)
830 "object" => %{"type" => "Like", "object" => object_id},
836 with actor <- Containment.get_actor(data),
837 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
838 {:ok, object} <- get_obj_helper(object_id),
839 {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
846 # For Undos that don't have the complete object attached, try to find it in our database.
854 when is_binary(object) do
855 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
857 |> Map.put("object", data)
858 |> handle_incoming(options)
867 "actor" => origin_actor,
868 "object" => origin_actor,
869 "target" => target_actor
873 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
874 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
875 true <- origin_actor in target_user.also_known_as do
876 ActivityPub.move(origin_user, target_user, false)
882 def handle_incoming(_, _), do: :error
884 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
885 def get_obj_helper(id, options \\ []) do
886 case Object.normalize(id, true, options) do
887 %Object{} = object -> {:ok, object}
892 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
893 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
896 when attributed_to == ap_id do
897 with {:ok, activity} <-
902 "actor" => attributed_to,
905 {:ok, Object.normalize(activity)}
907 _ -> get_obj_helper(object_id)
911 def get_embedded_obj_helper(object_id, _) do
912 get_obj_helper(object_id)
915 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
916 with false <- String.starts_with?(in_reply_to, "http"),
917 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
918 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
924 def set_reply_to_uri(obj), do: obj
927 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
928 Based on Mastodon's ActivityPub::NoteSerializer#replies.
930 def set_replies(obj_data) do
932 with limit when limit > 0 <-
933 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
934 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
936 |> Object.self_replies()
937 |> select([o], fragment("?->>'id'", o.data))
944 set_replies(obj_data, replies_uris)
947 defp set_replies(obj, []) do
951 defp set_replies(obj, replies_uris) do
952 replies_collection = %{
953 "type" => "Collection",
954 "items" => replies_uris
957 Map.merge(obj, %{"replies" => replies_collection})
960 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
964 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
968 def replies(_), do: []
970 # Prepares the object of an outgoing create activity.
971 def prepare_object(object) do
978 |> prepare_attachments
982 |> strip_internal_fields
983 |> strip_internal_tags
989 # internal -> Mastodon
992 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
993 when activity_type in ["Create", "Listen"] do
996 |> Object.normalize()
1002 |> Map.put("object", object)
1003 |> Map.merge(Utils.make_json_ld_header())
1004 |> Map.delete("bcc")
1009 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
1012 |> Object.normalize()
1015 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1016 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1018 data |> maybe_fix_object_url
1023 |> strip_internal_fields
1024 |> Map.merge(Utils.make_json_ld_header())
1025 |> Map.delete("bcc")
1030 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1031 # because of course it does.
1032 def prepare_outgoing(%{"type" => "Accept"} = data) do
1033 with follow_activity <- Activity.normalize(data["object"]) do
1035 "actor" => follow_activity.actor,
1036 "object" => follow_activity.data["object"],
1037 "id" => follow_activity.data["id"],
1043 |> Map.put("object", object)
1044 |> Map.merge(Utils.make_json_ld_header())
1050 def prepare_outgoing(%{"type" => "Reject"} = data) do
1051 with follow_activity <- Activity.normalize(data["object"]) do
1053 "actor" => follow_activity.actor,
1054 "object" => follow_activity.data["object"],
1055 "id" => follow_activity.data["id"],
1061 |> Map.put("object", object)
1062 |> Map.merge(Utils.make_json_ld_header())
1068 def prepare_outgoing(%{"type" => _type} = data) do
1071 |> strip_internal_fields
1072 |> maybe_fix_object_url
1073 |> Map.merge(Utils.make_json_ld_header())
1078 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1079 with false <- String.starts_with?(object, "http"),
1080 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1081 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1083 Map.put(data, "object", external_url)
1086 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1094 def maybe_fix_object_url(data), do: data
1096 def add_hashtags(object) do
1098 (object["tag"] || [])
1100 # Expand internal representation tags into AS2 tags.
1101 tag when is_binary(tag) ->
1103 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1104 "name" => "##{tag}",
1108 # Do not process tags which are already AS2 tag objects.
1109 tag when is_map(tag) ->
1113 Map.put(object, "tag", tags)
1116 def add_mention_tags(object) do
1117 {enabled_receivers, disabled_receivers} = Utils.get_notified_from_object(object)
1118 potential_receivers = enabled_receivers ++ disabled_receivers
1119 mentions = Enum.map(potential_receivers, &build_mention_tag/1)
1121 tags = object["tag"] || []
1122 Map.put(object, "tag", tags ++ mentions)
1125 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1126 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1129 def take_emoji_tags(%User{emoji: emoji}) do
1131 |> Enum.flat_map(&Map.to_list/1)
1132 |> Enum.map(&build_emoji_tag/1)
1135 # TODO: we should probably send mtime instead of unix epoch time for updated
1136 def add_emoji_tags(%{"emoji" => emoji} = object) do
1137 tags = object["tag"] || []
1139 out = Enum.map(emoji, &build_emoji_tag/1)
1141 Map.put(object, "tag", tags ++ out)
1144 def add_emoji_tags(object), do: object
1146 defp build_emoji_tag({name, url}) do
1148 "icon" => %{"url" => url, "type" => "Image"},
1149 "name" => ":" <> name <> ":",
1151 "updated" => "1970-01-01T00:00:00Z",
1156 def set_conversation(object) do
1157 Map.put(object, "conversation", object["context"])
1160 def set_sensitive(object) do
1161 tags = object["tag"] || []
1162 Map.put(object, "sensitive", "nsfw" in tags)
1165 def set_type(%{"type" => "Answer"} = object) do
1166 Map.put(object, "type", "Note")
1169 def set_type(object), do: object
1171 def add_attributed_to(object) do
1172 attributed_to = object["attributedTo"] || object["actor"]
1173 Map.put(object, "attributedTo", attributed_to)
1176 def prepare_attachments(object) do
1178 (object["attachment"] || [])
1179 |> Enum.map(fn data ->
1180 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1181 %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1184 Map.put(object, "attachment", attachments)
1187 def strip_internal_fields(object) do
1189 |> Map.drop(Pleroma.Constants.object_internal_fields())
1192 defp strip_internal_tags(%{"tag" => tags} = object) do
1193 tags = Enum.filter(tags, fn x -> is_map(x) end)
1195 Map.put(object, "tag", tags)
1198 defp strip_internal_tags(object), do: object
1200 def perform(:user_upgrade, user) do
1201 # we pass a fake user so that the followers collection is stripped away
1202 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1206 where: ^old_follower_address in a.recipients,
1211 "array_replace(?,?,?)",
1213 ^old_follower_address,
1214 ^user.follower_address
1219 |> Repo.update_all([])
1222 def upgrade_user_from_ap_id(ap_id) do
1223 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1224 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1225 already_ap <- User.ap_enabled?(user),
1226 {:ok, user} <- upgrade_user(user, data) do
1227 if not already_ap do
1228 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1233 %User{} = user -> {:ok, user}
1238 defp upgrade_user(user, data) do
1240 |> User.upgrade_changeset(data, true)
1241 |> User.update_and_set_cache()
1244 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1245 Map.put(data, "url", url["href"])
1248 def maybe_fix_user_url(data), do: data
1250 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)