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
1112 {enabled_receivers, disabled_receivers} = Utils.get_notified_from_object(object)
1113 potential_receivers = enabled_receivers ++ disabled_receivers
1114 mentions = Enum.map(potential_receivers, &build_mention_tag/1)
1116 tags = object["tag"] || []
1117 Map.put(object, "tag", tags ++ mentions)
1120 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1121 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1124 def take_emoji_tags(%User{emoji: emoji}) do
1126 |> Enum.flat_map(&Map.to_list/1)
1127 |> Enum.map(&build_emoji_tag/1)
1130 # TODO: we should probably send mtime instead of unix epoch time for updated
1131 def add_emoji_tags(%{"emoji" => emoji} = object) do
1132 tags = object["tag"] || []
1134 out = Enum.map(emoji, &build_emoji_tag/1)
1136 Map.put(object, "tag", tags ++ out)
1139 def add_emoji_tags(object), do: object
1141 defp build_emoji_tag({name, url}) do
1143 "icon" => %{"url" => url, "type" => "Image"},
1144 "name" => ":" <> name <> ":",
1146 "updated" => "1970-01-01T00:00:00Z",
1151 def set_conversation(object) do
1152 Map.put(object, "conversation", object["context"])
1155 def set_sensitive(object) do
1156 tags = object["tag"] || []
1157 Map.put(object, "sensitive", "nsfw" in tags)
1160 def set_type(%{"type" => "Answer"} = object) do
1161 Map.put(object, "type", "Note")
1164 def set_type(object), do: object
1166 def add_attributed_to(object) do
1167 attributed_to = object["attributedTo"] || object["actor"]
1168 Map.put(object, "attributedTo", attributed_to)
1171 def prepare_attachments(object) do
1173 (object["attachment"] || [])
1174 |> Enum.map(fn data ->
1175 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1176 %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1179 Map.put(object, "attachment", attachments)
1182 def strip_internal_fields(object) do
1184 |> Map.drop(Pleroma.Constants.object_internal_fields())
1187 defp strip_internal_tags(%{"tag" => tags} = object) do
1188 tags = Enum.filter(tags, fn x -> is_map(x) end)
1190 Map.put(object, "tag", tags)
1193 defp strip_internal_tags(object), do: object
1195 def perform(:user_upgrade, user) do
1196 # we pass a fake user so that the followers collection is stripped away
1197 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1201 where: ^old_follower_address in a.recipients,
1206 "array_replace(?,?,?)",
1208 ^old_follower_address,
1209 ^user.follower_address
1214 |> Repo.update_all([])
1217 def upgrade_user_from_ap_id(ap_id) do
1218 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1219 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1220 already_ap <- User.ap_enabled?(user),
1221 {:ok, user} <- upgrade_user(user, data) do
1222 if not already_ap do
1223 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1228 %User{} = user -> {:ok, user}
1233 defp upgrade_user(user, data) do
1235 |> User.upgrade_changeset(data, true)
1236 |> User.update_and_set_cache()
1239 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1240 Map.put(data, "url", url["href"])
1243 def maybe_fix_user_url(data), do: data
1245 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)