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} <- FollowingRelationship.update(follower, followed, "accept") do
495 ActivityPub.accept(%{
496 to: [follower.ap_id],
502 {:user_blocked, true} ->
503 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
504 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
506 ActivityPub.reject(%{
507 to: [follower.ap_id],
513 {:follow, {:error, _}} ->
514 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
515 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
517 ActivityPub.reject(%{
518 to: [follower.ap_id],
524 {:user_locked, true} ->
525 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "pending")
537 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
540 with actor <- Containment.get_actor(data),
541 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
542 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
543 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
544 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
545 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
546 ActivityPub.accept(%{
547 to: follow_activity.data["to"],
550 object: follow_activity.data["id"],
560 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
563 with actor <- Containment.get_actor(data),
564 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
565 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
566 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
567 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
568 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"),
570 ActivityPub.reject(%{
571 to: follow_activity.data["to"],
574 object: follow_activity.data["id"],
584 @misskey_reactions %{
598 @doc "Rewrite misskey likes into EmojiReacts"
602 "_misskey_reaction" => reaction
607 |> Map.put("type", "EmojiReact")
608 |> Map.put("content", @misskey_reactions[reaction] || reaction)
609 |> handle_incoming(options)
613 %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
616 with actor <- Containment.get_actor(data),
617 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
618 {:ok, object} <- get_obj_helper(object_id),
619 {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
628 "type" => "EmojiReact",
629 "object" => object_id,
636 with actor <- Containment.get_actor(data),
637 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
638 {:ok, object} <- get_obj_helper(object_id),
639 {:ok, activity, _object} <-
640 ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
648 %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
651 with actor <- Containment.get_actor(data),
652 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
653 {:ok, object} <- get_embedded_obj_helper(object_id, actor),
654 public <- Visibility.is_public?(data),
655 {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
663 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
667 when object_type in [
673 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
674 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
677 |> User.upgrade_changeset(new_user_data, true)
678 |> User.update_and_set_cache()
680 ActivityPub.update(%{
682 to: data["to"] || [],
683 cc: data["cc"] || [],
686 activity_id: data["id"]
695 # TODO: We presently assume that any actor on the same origin domain as the object being
696 # deleted has the rights to delete that object. A better way to validate whether or not
697 # the object should be deleted is to refetch the object URI, which should return either
698 # an error or a tombstone. This would allow us to verify that a deletion actually took
701 %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
704 object_id = Utils.get_ap_id(object_id)
706 with actor <- Containment.get_actor(data),
707 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
708 {:ok, object} <- get_obj_helper(object_id),
709 :ok <- Containment.contain_origin(actor.ap_id, object.data),
711 ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
715 case User.get_cached_by_ap_id(object_id) do
716 %User{ap_id: ^actor} = user ->
731 "object" => %{"type" => "Announce", "object" => object_id},
737 with actor <- Containment.get_actor(data),
738 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
739 {:ok, object} <- get_obj_helper(object_id),
740 {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
750 "object" => %{"type" => "Follow", "object" => followed},
756 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
757 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
758 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
759 User.unfollow(follower, followed)
769 "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
775 with actor <- Containment.get_actor(data),
776 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
777 {:ok, activity, _} <-
778 ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
791 "object" => %{"type" => "Block", "object" => blocked},
797 with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
798 {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
799 {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
800 User.unblock(blocker, blocked)
808 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
811 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
812 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
813 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
814 User.unfollow(blocker, blocked)
815 User.block(blocker, blocked)
825 "object" => %{"type" => "Like", "object" => object_id},
831 with actor <- Containment.get_actor(data),
832 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
833 {:ok, object} <- get_obj_helper(object_id),
834 {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
841 # For Undos that don't have the complete object attached, try to find it in our database.
849 when is_binary(object) do
850 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
852 |> Map.put("object", data)
853 |> handle_incoming(options)
862 "actor" => origin_actor,
863 "object" => origin_actor,
864 "target" => target_actor
868 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
869 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
870 true <- origin_actor in target_user.also_known_as do
871 ActivityPub.move(origin_user, target_user, false)
877 def handle_incoming(_, _), do: :error
879 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
880 def get_obj_helper(id, options \\ []) do
881 case Object.normalize(id, true, options) do
882 %Object{} = object -> {:ok, object}
887 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
888 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
891 when attributed_to == ap_id do
892 with {:ok, activity} <-
897 "actor" => attributed_to,
900 {:ok, Object.normalize(activity)}
902 _ -> get_obj_helper(object_id)
906 def get_embedded_obj_helper(object_id, _) do
907 get_obj_helper(object_id)
910 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
911 with false <- String.starts_with?(in_reply_to, "http"),
912 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
913 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
919 def set_reply_to_uri(obj), do: obj
922 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
923 Based on Mastodon's ActivityPub::NoteSerializer#replies.
925 def set_replies(obj_data) do
927 with limit when limit > 0 <-
928 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
929 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
931 |> Object.self_replies()
932 |> select([o], fragment("?->>'id'", o.data))
939 set_replies(obj_data, replies_uris)
942 defp set_replies(obj, []) do
946 defp set_replies(obj, replies_uris) do
947 replies_collection = %{
948 "type" => "Collection",
949 "items" => replies_uris
952 Map.merge(obj, %{"replies" => replies_collection})
955 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
959 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
963 def replies(_), do: []
965 # Prepares the object of an outgoing create activity.
966 def prepare_object(object) do
973 |> prepare_attachments
977 |> strip_internal_fields
978 |> strip_internal_tags
984 # internal -> Mastodon
987 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
988 when activity_type in ["Create", "Listen"] do
991 |> Object.normalize()
997 |> Map.put("object", object)
998 |> Map.merge(Utils.make_json_ld_header())
1004 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
1007 |> Object.normalize()
1010 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1011 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1013 data |> maybe_fix_object_url
1018 |> strip_internal_fields
1019 |> Map.merge(Utils.make_json_ld_header())
1020 |> Map.delete("bcc")
1025 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1026 # because of course it does.
1027 def prepare_outgoing(%{"type" => "Accept"} = data) do
1028 with follow_activity <- Activity.normalize(data["object"]) do
1030 "actor" => follow_activity.actor,
1031 "object" => follow_activity.data["object"],
1032 "id" => follow_activity.data["id"],
1038 |> Map.put("object", object)
1039 |> Map.merge(Utils.make_json_ld_header())
1045 def prepare_outgoing(%{"type" => "Reject"} = data) do
1046 with follow_activity <- Activity.normalize(data["object"]) do
1048 "actor" => follow_activity.actor,
1049 "object" => follow_activity.data["object"],
1050 "id" => follow_activity.data["id"],
1056 |> Map.put("object", object)
1057 |> Map.merge(Utils.make_json_ld_header())
1063 def prepare_outgoing(%{"type" => _type} = data) do
1066 |> strip_internal_fields
1067 |> maybe_fix_object_url
1068 |> Map.merge(Utils.make_json_ld_header())
1073 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1074 with false <- String.starts_with?(object, "http"),
1075 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1076 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1078 Map.put(data, "object", external_url)
1081 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1089 def maybe_fix_object_url(data), do: data
1091 def add_hashtags(object) do
1093 (object["tag"] || [])
1095 # Expand internal representation tags into AS2 tags.
1096 tag when is_binary(tag) ->
1098 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1099 "name" => "##{tag}",
1103 # Do not process tags which are already AS2 tag objects.
1104 tag when is_map(tag) ->
1108 Map.put(object, "tag", tags)
1111 def add_mention_tags(object) do
1114 |> Utils.get_notified_from_object()
1115 |> Enum.map(&build_mention_tag/1)
1117 tags = object["tag"] || []
1119 Map.put(object, "tag", tags ++ mentions)
1122 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1123 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1126 def take_emoji_tags(%User{emoji: emoji}) do
1128 |> Enum.flat_map(&Map.to_list/1)
1129 |> Enum.map(&build_emoji_tag/1)
1132 # TODO: we should probably send mtime instead of unix epoch time for updated
1133 def add_emoji_tags(%{"emoji" => emoji} = object) do
1134 tags = object["tag"] || []
1136 out = Enum.map(emoji, &build_emoji_tag/1)
1138 Map.put(object, "tag", tags ++ out)
1141 def add_emoji_tags(object), do: object
1143 defp build_emoji_tag({name, url}) do
1145 "icon" => %{"url" => url, "type" => "Image"},
1146 "name" => ":" <> name <> ":",
1148 "updated" => "1970-01-01T00:00:00Z",
1153 def set_conversation(object) do
1154 Map.put(object, "conversation", object["context"])
1157 def set_sensitive(object) do
1158 tags = object["tag"] || []
1159 Map.put(object, "sensitive", "nsfw" in tags)
1162 def set_type(%{"type" => "Answer"} = object) do
1163 Map.put(object, "type", "Note")
1166 def set_type(object), do: object
1168 def add_attributed_to(object) do
1169 attributed_to = object["attributedTo"] || object["actor"]
1170 Map.put(object, "attributedTo", attributed_to)
1173 def prepare_attachments(object) do
1175 (object["attachment"] || [])
1176 |> Enum.map(fn data ->
1177 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1178 %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1181 Map.put(object, "attachment", attachments)
1184 def strip_internal_fields(object) do
1186 |> Map.drop(Pleroma.Constants.object_internal_fields())
1189 defp strip_internal_tags(%{"tag" => tags} = object) do
1190 tags = Enum.filter(tags, fn x -> is_map(x) end)
1192 Map.put(object, "tag", tags)
1195 defp strip_internal_tags(object), do: object
1197 def perform(:user_upgrade, user) do
1198 # we pass a fake user so that the followers collection is stripped away
1199 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1203 where: ^old_follower_address in a.recipients,
1208 "array_replace(?,?,?)",
1210 ^old_follower_address,
1211 ^user.follower_address
1216 |> Repo.update_all([])
1219 def upgrade_user_from_ap_id(ap_id) do
1220 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1221 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1222 already_ap <- User.ap_enabled?(user),
1223 {:ok, user} <- upgrade_user(user, data) do
1224 if not already_ap do
1225 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1230 %User{} = user -> {:ok, user}
1235 defp upgrade_user(user, data) do
1237 |> User.upgrade_changeset(data, true)
1238 |> User.update_and_set_cache()
1241 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1242 Map.put(data, "url", url["href"])
1245 def maybe_fix_user_url(data), do: data
1247 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)