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 defp add_if_present(map, _key, nil), do: map
207 defp add_if_present(map, key, value) do
208 Map.put(map, key, value)
211 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
213 Enum.map(attachment, fn data ->
216 is_list(data["url"]) -> List.first(data["url"])
217 is_map(data["url"]) -> data["url"]
223 is_map(url) && is_binary(url["mediaType"]) -> url["mediaType"]
224 is_binary(data["mediaType"]) -> data["mediaType"]
225 is_binary(data["mimeType"]) -> data["mimeType"]
231 is_map(url) && is_binary(url["href"]) -> url["href"]
232 is_binary(data["url"]) -> data["url"]
233 is_binary(data["href"]) -> data["href"]
238 |> add_if_present("mediaType", media_type)
239 |> add_if_present("type", Map.get(url || %{}, "type"))
241 %{"url" => [attachment_url]}
242 |> add_if_present("mediaType", media_type)
243 |> add_if_present("type", data["type"])
244 |> add_if_present("name", data["name"])
247 Map.put(object, "attachment", attachments)
250 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
252 |> Map.put("attachment", [attachment])
256 def fix_attachments(object), do: object
258 def fix_url(%{"url" => url} = object) when is_map(url) do
259 Map.put(object, "url", url["href"])
262 def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
263 first_element = Enum.at(url, 0)
265 link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
268 |> Map.put("attachment", [first_element])
269 |> Map.put("url", link_element["href"])
272 def fix_url(%{"type" => object_type, "url" => url} = object)
273 when object_type != "Video" and is_list(url) do
274 first_element = Enum.at(url, 0)
278 is_bitstring(first_element) -> first_element
279 is_map(first_element) -> first_element["href"] || ""
283 Map.put(object, "url", url_string)
286 def fix_url(object), do: object
288 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
291 |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
292 |> Enum.reduce(%{}, fn data, mapping ->
293 name = String.trim(data["name"], ":")
295 Map.put(mapping, name, data["icon"]["url"])
298 # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
299 emoji = Map.merge(object["emoji"] || %{}, emoji)
301 Map.put(object, "emoji", emoji)
304 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
305 name = String.trim(tag["name"], ":")
306 emoji = %{name => tag["icon"]["url"]}
308 Map.put(object, "emoji", emoji)
311 def fix_emoji(object), do: object
313 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
316 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
317 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
319 Map.put(object, "tag", tag ++ tags)
322 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
323 combined = [tag, String.slice(hashtag, 1..-1)]
325 Map.put(object, "tag", combined)
328 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
330 def fix_tag(object), do: object
332 # content map usually only has one language so this will do for now.
333 def fix_content_map(%{"contentMap" => content_map} = object) do
334 content_groups = Map.to_list(content_map)
335 {_, content} = Enum.at(content_groups, 0)
337 Map.put(object, "content", content)
340 def fix_content_map(object), do: object
342 def fix_type(object, options \\ [])
344 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
345 when is_binary(reply_id) do
346 with true <- Federator.allowed_thread_distance?(options[:depth]),
347 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
348 Map.put(object, "type", "Answer")
354 def fix_type(object, _), do: object
356 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
357 with true <- id =~ "follows",
358 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
359 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
366 defp mastodon_follow_hack(_, _), do: {:error, nil}
368 defp get_follow_activity(follow_object, followed) do
369 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
370 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
373 # Can't find the activity. This might a Mastodon 2.3 "Accept"
375 mastodon_follow_hack(follow_object, followed)
382 # Reduce the object list to find the reported user.
383 defp get_reported(objects) do
384 Enum.reduce_while(objects, nil, fn ap_id, _ ->
385 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
393 def handle_incoming(data, options \\ [])
395 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
397 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
398 with context <- data["context"] || Utils.generate_context_id(),
399 content <- data["content"] || "",
400 %User{} = actor <- User.get_cached_by_ap_id(actor),
401 # Reduce the object list to find the reported user.
402 %User{} = account <- get_reported(objects),
403 # Remove the reported user from the object list.
404 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
411 additional: %{"cc" => [account.ap_id]}
413 |> ActivityPub.flag()
417 # disallow objects with bogus IDs
418 def handle_incoming(%{"id" => nil}, _options), do: :error
419 def handle_incoming(%{"id" => ""}, _options), do: :error
420 # length of https:// = 8, should validate better, but good enough for now.
421 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
424 # TODO: validate those with a Ecto scheme
428 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
431 when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer"] do
432 actor = Containment.get_actor(data)
435 Map.put(data, "actor", actor)
438 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
439 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
440 object = fix_object(object, options)
446 context: object["conversation"],
448 published: data["published"],
457 with {:ok, created_activity} <- ActivityPub.create(params) do
458 reply_depth = (options[:depth] || 0) + 1
460 if Federator.allowed_thread_distance?(reply_depth) do
461 for reply_id <- replies(object) do
462 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
464 "depth" => reply_depth
469 {:ok, created_activity}
472 %Activity{} = activity -> {:ok, activity}
478 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
481 actor = Containment.get_actor(data)
484 Map.put(data, "actor", actor)
487 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
488 reply_depth = (options[:depth] || 0) + 1
489 options = Keyword.put(options, :depth, reply_depth)
490 object = fix_object(object, options)
498 published: data["published"],
499 additional: Map.take(data, ["cc", "id"])
502 ActivityPub.listen(params)
509 %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
512 with %User{local: true} = followed <-
513 User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
514 {:ok, %User{} = follower} <-
515 User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
516 {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
517 with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
518 {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
519 {_, false} <- {:user_locked, User.locked?(followed)},
520 {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
522 {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
523 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
524 ActivityPub.accept(%{
525 to: [follower.ap_id],
531 {:user_blocked, true} ->
532 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
533 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
535 ActivityPub.reject(%{
536 to: [follower.ap_id],
542 {:follow, {:error, _}} ->
543 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
544 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
546 ActivityPub.reject(%{
547 to: [follower.ap_id],
553 {:user_locked, true} ->
554 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "pending")
566 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
569 with actor <- Containment.get_actor(data),
570 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
571 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
572 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
573 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
574 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
575 ActivityPub.accept(%{
576 to: follow_activity.data["to"],
579 object: follow_activity.data["id"],
589 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
592 with actor <- Containment.get_actor(data),
593 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
594 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
595 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
596 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
597 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"),
599 ActivityPub.reject(%{
600 to: follow_activity.data["to"],
603 object: follow_activity.data["id"],
613 @misskey_reactions %{
627 @doc "Rewrite misskey likes into EmojiReacts"
631 "_misskey_reaction" => reaction
636 |> Map.put("type", "EmojiReact")
637 |> Map.put("content", @misskey_reactions[reaction] || reaction)
638 |> handle_incoming(options)
642 %{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data,
645 with actor <- Containment.get_actor(data),
646 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
647 {:ok, object} <- get_obj_helper(object_id),
648 {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
657 "type" => "EmojiReact",
658 "object" => object_id,
665 with actor <- Containment.get_actor(data),
666 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
667 {:ok, object} <- get_obj_helper(object_id),
668 {:ok, activity, _object} <-
669 ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
677 %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
680 with actor <- Containment.get_actor(data),
681 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
682 {:ok, object} <- get_embedded_obj_helper(object_id, actor),
683 public <- Visibility.is_public?(data),
684 {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
692 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
696 when object_type in [
702 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
703 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
706 |> User.upgrade_changeset(new_user_data, true)
707 |> User.update_and_set_cache()
709 ActivityPub.update(%{
711 to: data["to"] || [],
712 cc: data["cc"] || [],
715 activity_id: data["id"]
724 # TODO: We presently assume that any actor on the same origin domain as the object being
725 # deleted has the rights to delete that object. A better way to validate whether or not
726 # the object should be deleted is to refetch the object URI, which should return either
727 # an error or a tombstone. This would allow us to verify that a deletion actually took
730 %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
733 object_id = Utils.get_ap_id(object_id)
735 with actor <- Containment.get_actor(data),
736 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
737 {:ok, object} <- get_obj_helper(object_id),
738 :ok <- Containment.contain_origin(actor.ap_id, object.data),
740 ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
744 case User.get_cached_by_ap_id(object_id) do
745 %User{ap_id: ^actor} = user ->
760 "object" => %{"type" => "Announce", "object" => object_id},
766 with actor <- Containment.get_actor(data),
767 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
768 {:ok, object} <- get_obj_helper(object_id),
769 {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
779 "object" => %{"type" => "Follow", "object" => followed},
785 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
786 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
787 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
788 User.unfollow(follower, followed)
798 "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
804 with actor <- Containment.get_actor(data),
805 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
806 {:ok, activity, _} <-
807 ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
820 "object" => %{"type" => "Block", "object" => blocked},
826 with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
827 {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
828 {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
829 User.unblock(blocker, blocked)
837 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
840 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
841 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
842 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
843 User.unfollow(blocker, blocked)
844 User.block(blocker, blocked)
854 "object" => %{"type" => "Like", "object" => object_id},
860 with actor <- Containment.get_actor(data),
861 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
862 {:ok, object} <- get_obj_helper(object_id),
863 {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
870 # For Undos that don't have the complete object attached, try to find it in our database.
878 when is_binary(object) do
879 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
881 |> Map.put("object", data)
882 |> handle_incoming(options)
891 "actor" => origin_actor,
892 "object" => origin_actor,
893 "target" => target_actor
897 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
898 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
899 true <- origin_actor in target_user.also_known_as do
900 ActivityPub.move(origin_user, target_user, false)
906 def handle_incoming(_, _), do: :error
908 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
909 def get_obj_helper(id, options \\ []) do
910 case Object.normalize(id, true, options) do
911 %Object{} = object -> {:ok, object}
916 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
917 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
920 when attributed_to == ap_id do
921 with {:ok, activity} <-
926 "actor" => attributed_to,
929 {:ok, Object.normalize(activity)}
931 _ -> get_obj_helper(object_id)
935 def get_embedded_obj_helper(object_id, _) do
936 get_obj_helper(object_id)
939 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
940 with false <- String.starts_with?(in_reply_to, "http"),
941 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
942 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
948 def set_reply_to_uri(obj), do: obj
951 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
952 Based on Mastodon's ActivityPub::NoteSerializer#replies.
954 def set_replies(obj_data) do
956 with limit when limit > 0 <-
957 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
958 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
960 |> Object.self_replies()
961 |> select([o], fragment("?->>'id'", o.data))
968 set_replies(obj_data, replies_uris)
971 defp set_replies(obj, []) do
975 defp set_replies(obj, replies_uris) do
976 replies_collection = %{
977 "type" => "Collection",
978 "items" => replies_uris
981 Map.merge(obj, %{"replies" => replies_collection})
984 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
988 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
992 def replies(_), do: []
994 # Prepares the object of an outgoing create activity.
995 def prepare_object(object) do
1001 |> add_attributed_to
1002 |> prepare_attachments
1006 |> strip_internal_fields
1007 |> strip_internal_tags
1013 # internal -> Mastodon
1016 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
1017 when activity_type in ["Create", "Listen"] do
1020 |> Object.normalize()
1026 |> Map.put("object", object)
1027 |> Map.merge(Utils.make_json_ld_header())
1028 |> Map.delete("bcc")
1033 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
1036 |> Object.normalize()
1039 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1040 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1042 data |> maybe_fix_object_url
1047 |> strip_internal_fields
1048 |> Map.merge(Utils.make_json_ld_header())
1049 |> Map.delete("bcc")
1054 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1055 # because of course it does.
1056 def prepare_outgoing(%{"type" => "Accept"} = data) do
1057 with follow_activity <- Activity.normalize(data["object"]) do
1059 "actor" => follow_activity.actor,
1060 "object" => follow_activity.data["object"],
1061 "id" => follow_activity.data["id"],
1067 |> Map.put("object", object)
1068 |> Map.merge(Utils.make_json_ld_header())
1074 def prepare_outgoing(%{"type" => "Reject"} = data) do
1075 with follow_activity <- Activity.normalize(data["object"]) do
1077 "actor" => follow_activity.actor,
1078 "object" => follow_activity.data["object"],
1079 "id" => follow_activity.data["id"],
1085 |> Map.put("object", object)
1086 |> Map.merge(Utils.make_json_ld_header())
1092 def prepare_outgoing(%{"type" => _type} = data) do
1095 |> strip_internal_fields
1096 |> maybe_fix_object_url
1097 |> Map.merge(Utils.make_json_ld_header())
1102 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1103 with false <- String.starts_with?(object, "http"),
1104 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1105 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1107 Map.put(data, "object", external_url)
1110 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1118 def maybe_fix_object_url(data), do: data
1120 def add_hashtags(object) do
1122 (object["tag"] || [])
1124 # Expand internal representation tags into AS2 tags.
1125 tag when is_binary(tag) ->
1127 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1128 "name" => "##{tag}",
1132 # Do not process tags which are already AS2 tag objects.
1133 tag when is_map(tag) ->
1137 Map.put(object, "tag", tags)
1140 def add_mention_tags(object) do
1143 |> Utils.get_notified_from_object()
1144 |> Enum.map(&build_mention_tag/1)
1146 tags = object["tag"] || []
1148 Map.put(object, "tag", tags ++ mentions)
1151 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1152 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1155 def take_emoji_tags(%User{emoji: emoji}) do
1157 |> Enum.flat_map(&Map.to_list/1)
1158 |> Enum.map(&build_emoji_tag/1)
1161 # TODO: we should probably send mtime instead of unix epoch time for updated
1162 def add_emoji_tags(%{"emoji" => emoji} = object) do
1163 tags = object["tag"] || []
1165 out = Enum.map(emoji, &build_emoji_tag/1)
1167 Map.put(object, "tag", tags ++ out)
1170 def add_emoji_tags(object), do: object
1172 defp build_emoji_tag({name, url}) do
1174 "icon" => %{"url" => url, "type" => "Image"},
1175 "name" => ":" <> name <> ":",
1177 "updated" => "1970-01-01T00:00:00Z",
1182 def set_conversation(object) do
1183 Map.put(object, "conversation", object["context"])
1186 def set_sensitive(object) do
1187 tags = object["tag"] || []
1188 Map.put(object, "sensitive", "nsfw" in tags)
1191 def set_type(%{"type" => "Answer"} = object) do
1192 Map.put(object, "type", "Note")
1195 def set_type(object), do: object
1197 def add_attributed_to(object) do
1198 attributed_to = object["attributedTo"] || object["actor"]
1199 Map.put(object, "attributedTo", attributed_to)
1202 def prepare_attachments(object) do
1204 (object["attachment"] || [])
1205 |> Enum.map(fn data ->
1206 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1207 %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1210 Map.put(object, "attachment", attachments)
1213 def strip_internal_fields(object) do
1215 |> Map.drop(Pleroma.Constants.object_internal_fields())
1218 defp strip_internal_tags(%{"tag" => tags} = object) do
1219 tags = Enum.filter(tags, fn x -> is_map(x) end)
1221 Map.put(object, "tag", tags)
1224 defp strip_internal_tags(object), do: object
1226 def perform(:user_upgrade, user) do
1227 # we pass a fake user so that the followers collection is stripped away
1228 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1232 where: ^old_follower_address in a.recipients,
1237 "array_replace(?,?,?)",
1239 ^old_follower_address,
1240 ^user.follower_address
1245 |> Repo.update_all([])
1248 def upgrade_user_from_ap_id(ap_id) do
1249 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1250 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1251 already_ap <- User.ap_enabled?(user),
1252 {:ok, user} <- upgrade_user(user, data) do
1253 if not already_ap do
1254 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1259 %User{} = user -> {:ok, user}
1264 defp upgrade_user(user, data) do
1266 |> User.upgrade_changeset(data, true)
1267 |> User.update_and_set_cache()
1270 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1271 Map.put(data, "url", url["href"])
1274 def maybe_fix_user_url(data), do: data
1276 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)