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.ObjectValidator
17 alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
18 alias Pleroma.Web.ActivityPub.Pipeline
19 alias Pleroma.Web.ActivityPub.Utils
20 alias Pleroma.Web.ActivityPub.Visibility
21 alias Pleroma.Web.Federator
22 alias Pleroma.Workers.TransmogrifierWorker
27 require Pleroma.Constants
30 Modifies an incoming AP object (mastodon format) to our internal format.
32 def fix_object(object, options \\ []) do
34 |> strip_internal_fields
39 |> fix_in_reply_to(options)
48 def fix_summary(%{"summary" => nil} = object) do
49 Map.put(object, "summary", "")
52 def fix_summary(%{"summary" => _} = object) do
53 # summary is present, nothing to do
57 def fix_summary(object), do: Map.put(object, "summary", "")
59 def fix_addressing_list(map, field) do
61 is_binary(map[field]) ->
62 Map.put(map, field, [map[field]])
65 Map.put(map, field, [])
72 def fix_explicit_addressing(
73 %{"to" => to, "cc" => cc} = object,
77 explicit_to = Enum.filter(to, fn x -> x in explicit_mentions end)
79 explicit_cc = Enum.filter(to, fn x -> x not in explicit_mentions end)
83 |> Enum.reject(fn x -> String.ends_with?(x, "/followers") and x != follower_collection end)
87 |> Map.put("to", explicit_to)
88 |> Map.put("cc", final_cc)
91 def fix_explicit_addressing(object, _explicit_mentions, _followers_collection), do: object
93 # if directMessage flag is set to true, leave the addressing alone
94 def fix_explicit_addressing(%{"directMessage" => true} = object), do: object
96 def fix_explicit_addressing(object) do
97 explicit_mentions = Utils.determine_explicit_mentions(object)
99 %User{follower_address: follower_collection} =
101 |> Containment.get_actor()
102 |> User.get_cached_by_ap_id()
107 Pleroma.Constants.as_public(),
111 fix_explicit_addressing(object, explicit_mentions, follower_collection)
114 # if as:Public is addressed, then make sure the followers collection is also addressed
115 # so that the activities will be delivered to local users.
116 def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
117 recipients = to ++ cc
119 if followers_collection not in recipients do
121 Pleroma.Constants.as_public() in cc ->
122 to = to ++ [followers_collection]
123 Map.put(object, "to", to)
125 Pleroma.Constants.as_public() in to ->
126 cc = cc ++ [followers_collection]
127 Map.put(object, "cc", cc)
137 def fix_implicit_addressing(object, _), do: object
139 def fix_addressing(object) do
140 {:ok, %User{} = user} = User.get_or_fetch_by_ap_id(object["actor"])
141 followers_collection = User.ap_followers(user)
144 |> fix_addressing_list("to")
145 |> fix_addressing_list("cc")
146 |> fix_addressing_list("bto")
147 |> fix_addressing_list("bcc")
148 |> fix_explicit_addressing()
149 |> fix_implicit_addressing(followers_collection)
152 def fix_actor(%{"attributedTo" => actor} = object) do
153 Map.put(object, "actor", Containment.get_actor(%{"actor" => actor}))
156 def fix_in_reply_to(object, options \\ [])
158 def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object, options)
159 when not is_nil(in_reply_to) do
160 in_reply_to_id = prepare_in_reply_to(in_reply_to)
161 object = Map.put(object, "inReplyToAtomUri", in_reply_to_id)
162 depth = (options[:depth] || 0) + 1
164 if Federator.allowed_thread_distance?(depth) do
165 with {:ok, replied_object} <- get_obj_helper(in_reply_to_id, options),
166 %Activity{} <- Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
168 |> Map.put("inReplyTo", replied_object.data["id"])
169 |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
170 |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
171 |> Map.put("context", replied_object.data["context"] || object["conversation"])
174 Logger.error("Couldn't fetch #{inspect(in_reply_to_id)}, error: #{inspect(e)}")
182 def fix_in_reply_to(object, _options), do: object
184 defp prepare_in_reply_to(in_reply_to) do
186 is_bitstring(in_reply_to) ->
189 is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
192 is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
193 Enum.at(in_reply_to, 0)
200 def fix_context(object) do
201 context = object["context"] || object["conversation"] || Utils.generate_context_id()
204 |> Map.put("context", context)
205 |> Map.put("conversation", context)
208 def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
210 Enum.map(attachment, fn data ->
211 media_type = data["mediaType"] || data["mimeType"]
212 href = data["url"] || data["href"]
213 url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]
216 |> Map.put("mediaType", media_type)
217 |> Map.put("url", url)
220 Map.put(object, "attachment", attachments)
223 def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
225 |> Map.put("attachment", [attachment])
229 def fix_attachments(object), do: object
231 def fix_url(%{"url" => url} = object) when is_map(url) do
232 Map.put(object, "url", url["href"])
235 def fix_url(%{"type" => object_type, "url" => url} = object)
236 when object_type in ["Video", "Audio"] and is_list(url) do
237 first_element = Enum.at(url, 0)
239 link_element = Enum.find(url, fn x -> is_map(x) and x["mimeType"] == "text/html" end)
242 |> Map.put("attachment", [first_element])
243 |> Map.put("url", link_element["href"])
246 def fix_url(%{"type" => object_type, "url" => url} = object)
247 when object_type != "Video" and is_list(url) do
248 first_element = Enum.at(url, 0)
252 is_bitstring(first_element) -> first_element
253 is_map(first_element) -> first_element["href"] || ""
257 Map.put(object, "url", url_string)
260 def fix_url(object), do: object
262 def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
265 |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
266 |> Enum.reduce(%{}, fn data, mapping ->
267 name = String.trim(data["name"], ":")
269 Map.put(mapping, name, data["icon"]["url"])
272 # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
273 emoji = Map.merge(object["emoji"] || %{}, emoji)
275 Map.put(object, "emoji", emoji)
278 def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
279 name = String.trim(tag["name"], ":")
280 emoji = %{name => tag["icon"]["url"]}
282 Map.put(object, "emoji", emoji)
285 def fix_emoji(object), do: object
287 def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
290 |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
291 |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
293 Map.put(object, "tag", tag ++ tags)
296 def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
297 combined = [tag, String.slice(hashtag, 1..-1)]
299 Map.put(object, "tag", combined)
302 def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])
304 def fix_tag(object), do: object
306 # content map usually only has one language so this will do for now.
307 def fix_content_map(%{"contentMap" => content_map} = object) do
308 content_groups = Map.to_list(content_map)
309 {_, content} = Enum.at(content_groups, 0)
311 Map.put(object, "content", content)
314 def fix_content_map(object), do: object
316 def fix_type(object, options \\ [])
318 def fix_type(%{"inReplyTo" => reply_id, "name" => _} = object, options)
319 when is_binary(reply_id) do
320 with true <- Federator.allowed_thread_distance?(options[:depth]),
321 {:ok, %{data: %{"type" => "Question"} = _} = _} <- get_obj_helper(reply_id, options) do
322 Map.put(object, "type", "Answer")
328 def fix_type(object, _), do: object
330 defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
331 with true <- id =~ "follows",
332 %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
333 %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
340 defp mastodon_follow_hack(_, _), do: {:error, nil}
342 defp get_follow_activity(follow_object, followed) do
343 with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
344 {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
347 # Can't find the activity. This might a Mastodon 2.3 "Accept"
349 mastodon_follow_hack(follow_object, followed)
356 # Reduce the object list to find the reported user.
357 defp get_reported(objects) do
358 Enum.reduce_while(objects, nil, fn ap_id, _ ->
359 with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
367 def handle_incoming(data, options \\ [])
369 # Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
371 def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data, _options) do
372 with context <- data["context"] || Utils.generate_context_id(),
373 content <- data["content"] || "",
374 %User{} = actor <- User.get_cached_by_ap_id(actor),
375 # Reduce the object list to find the reported user.
376 %User{} = account <- get_reported(objects),
377 # Remove the reported user from the object list.
378 statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
385 additional: %{"cc" => [account.ap_id]}
387 |> ActivityPub.flag()
391 # disallow objects with bogus IDs
392 def handle_incoming(%{"id" => nil}, _options), do: :error
393 def handle_incoming(%{"id" => ""}, _options), do: :error
394 # length of https:// = 8, should validate better, but good enough for now.
395 def handle_incoming(%{"id" => id}, _options) when is_binary(id) and byte_size(id) < 8,
398 # TODO: validate those with a Ecto scheme
402 %{"type" => "Create", "object" => %{"type" => objtype} = object} = data,
405 when objtype in ["Article", "Event", "Note", "Video", "Page", "Question", "Answer", "Audio"] do
406 actor = Containment.get_actor(data)
409 Map.put(data, "actor", actor)
412 with nil <- Activity.get_create_by_object_ap_id(object["id"]),
413 {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
414 object = fix_object(object, options)
420 context: object["conversation"],
422 published: data["published"],
431 with {:ok, created_activity} <- ActivityPub.create(params) do
432 reply_depth = (options[:depth] || 0) + 1
434 if Federator.allowed_thread_distance?(reply_depth) do
435 for reply_id <- replies(object) do
436 Pleroma.Workers.RemoteFetcherWorker.enqueue("fetch_remote", %{
438 "depth" => reply_depth
443 {:ok, created_activity}
446 %Activity{} = activity -> {:ok, activity}
452 %{"type" => "Listen", "object" => %{"type" => "Audio"} = object} = data,
455 actor = Containment.get_actor(data)
458 Map.put(data, "actor", actor)
461 with {:ok, %User{} = user} <- User.get_or_fetch_by_ap_id(data["actor"]) do
462 reply_depth = (options[:depth] || 0) + 1
463 options = Keyword.put(options, :depth, reply_depth)
464 object = fix_object(object, options)
472 published: data["published"],
473 additional: Map.take(data, ["cc", "id"])
476 ActivityPub.listen(params)
483 %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data,
486 with %User{local: true} = followed <-
487 User.get_cached_by_ap_id(Containment.get_actor(%{"actor" => followed})),
488 {:ok, %User{} = follower} <-
489 User.get_or_fetch_by_ap_id(Containment.get_actor(%{"actor" => follower})),
490 {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
491 with deny_follow_blocked <- Pleroma.Config.get([:user, :deny_follow_blocked]),
492 {_, false} <- {:user_blocked, User.blocks?(followed, follower) && deny_follow_blocked},
493 {_, false} <- {:user_locked, User.locked?(followed)},
494 {_, {:ok, follower}} <- {:follow, User.follow(follower, followed)},
496 {:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")},
497 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
498 ActivityPub.accept(%{
499 to: [follower.ap_id],
505 {:user_blocked, true} ->
506 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
507 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
509 ActivityPub.reject(%{
510 to: [follower.ap_id],
516 {:follow, {:error, _}} ->
517 {:ok, _} = Utils.update_follow_state_for_all(activity, "reject")
518 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject")
520 ActivityPub.reject(%{
521 to: [follower.ap_id],
527 {:user_locked, true} ->
528 {:ok, _relationship} = FollowingRelationship.update(follower, followed, "pending")
540 %{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => id} = data,
543 with actor <- Containment.get_actor(data),
544 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
545 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
546 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
547 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
548 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do
549 ActivityPub.accept(%{
550 to: follow_activity.data["to"],
553 object: follow_activity.data["id"],
563 %{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => id} = data,
566 with actor <- Containment.get_actor(data),
567 {:ok, %User{} = followed} <- User.get_or_fetch_by_ap_id(actor),
568 {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
569 {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"),
570 %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
571 {:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"),
573 ActivityPub.reject(%{
574 to: follow_activity.data["to"],
577 object: follow_activity.data["id"],
587 @misskey_reactions %{
601 @doc "Rewrite misskey likes into EmojiReacts"
605 "_misskey_reaction" => reaction
610 |> Map.put("type", "EmojiReact")
611 |> Map.put("content", @misskey_reactions[reaction] || reaction)
612 |> handle_incoming(options)
615 def handle_incoming(%{"type" => "Like"} = data, _options) do
616 with {_, {:ok, cast_data_sym}} <-
618 data |> LikeValidator.cast_data() |> Ecto.Changeset.apply_action(:insert)},
619 cast_data = ObjectValidator.stringify_keys(Map.from_struct(cast_data_sym)),
620 :ok <- ObjectValidator.fetch_actor_and_object(cast_data),
621 {_, {:ok, cast_data}} <- {:ensure_context_presence, ensure_context_presence(cast_data)},
622 {_, {:ok, cast_data}} <-
623 {:ensure_recipients_presence, ensure_recipients_presence(cast_data)},
624 {_, {:ok, activity, _meta}} <-
625 {:common_pipeline, Pipeline.common_pipeline(cast_data, local: false)} do
634 "type" => "EmojiReact",
635 "object" => object_id,
642 with actor <- Containment.get_actor(data),
643 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
644 {:ok, object} <- get_obj_helper(object_id),
645 {:ok, activity, _object} <-
646 ActivityPub.react_with_emoji(actor, object, emoji, activity_id: id, local: false) do
654 %{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data,
657 with actor <- Containment.get_actor(data),
658 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
659 {:ok, object} <- get_embedded_obj_helper(object_id, actor),
660 public <- Visibility.is_public?(data),
661 {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
669 %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
673 when object_type in [
679 with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
680 {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
683 |> User.upgrade_changeset(new_user_data, true)
684 |> User.update_and_set_cache()
686 ActivityPub.update(%{
688 to: data["to"] || [],
689 cc: data["cc"] || [],
692 activity_id: data["id"]
701 # TODO: We presently assume that any actor on the same origin domain as the object being
702 # deleted has the rights to delete that object. A better way to validate whether or not
703 # the object should be deleted is to refetch the object URI, which should return either
704 # an error or a tombstone. This would allow us to verify that a deletion actually took
707 %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data,
710 object_id = Utils.get_ap_id(object_id)
712 with actor <- Containment.get_actor(data),
713 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
714 {:ok, object} <- get_obj_helper(object_id),
715 :ok <- Containment.contain_origin(actor.ap_id, object.data),
717 ActivityPub.delete(object, local: false, activity_id: id, actor: actor.ap_id) do
721 case User.get_cached_by_ap_id(object_id) do
722 %User{ap_id: ^actor} = user ->
737 "object" => %{"type" => "Announce", "object" => object_id},
743 with actor <- Containment.get_actor(data),
744 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
745 {:ok, object} <- get_obj_helper(object_id),
746 {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
756 "object" => %{"type" => "Follow", "object" => followed},
762 with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
763 {:ok, %User{} = follower} <- User.get_or_fetch_by_ap_id(follower),
764 {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
765 User.unfollow(follower, followed)
775 "object" => %{"type" => "EmojiReact", "id" => reaction_activity_id},
781 with actor <- Containment.get_actor(data),
782 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
783 {:ok, activity, _} <-
784 ActivityPub.unreact_with_emoji(actor, reaction_activity_id,
797 "object" => %{"type" => "Block", "object" => blocked},
803 with %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
804 {:ok, %User{} = blocker} <- User.get_or_fetch_by_ap_id(blocker),
805 {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
806 User.unblock(blocker, blocked)
814 %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data,
817 with %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
818 {:ok, %User{} = blocker} = User.get_or_fetch_by_ap_id(blocker),
819 {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
820 User.unfollow(blocker, blocked)
821 User.block(blocker, blocked)
831 "object" => %{"type" => "Like", "object" => object_id},
837 with actor <- Containment.get_actor(data),
838 {:ok, %User{} = actor} <- User.get_or_fetch_by_ap_id(actor),
839 {:ok, object} <- get_obj_helper(object_id),
840 {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
847 # For Undos that don't have the complete object attached, try to find it in our database.
855 when is_binary(object) do
856 with %Activity{data: data} <- Activity.get_by_ap_id(object) do
858 |> Map.put("object", data)
859 |> handle_incoming(options)
868 "actor" => origin_actor,
869 "object" => origin_actor,
870 "target" => target_actor
874 with %User{} = origin_user <- User.get_cached_by_ap_id(origin_actor),
875 {:ok, %User{} = target_user} <- User.get_or_fetch_by_ap_id(target_actor),
876 true <- origin_actor in target_user.also_known_as do
877 ActivityPub.move(origin_user, target_user, false)
883 def handle_incoming(_, _), do: :error
885 @spec get_obj_helper(String.t(), Keyword.t()) :: {:ok, Object.t()} | nil
886 def get_obj_helper(id, options \\ []) do
887 case Object.normalize(id, true, options) do
888 %Object{} = object -> {:ok, object}
893 @spec get_embedded_obj_helper(String.t() | Object.t(), User.t()) :: {:ok, Object.t()} | nil
894 def get_embedded_obj_helper(%{"attributedTo" => attributed_to, "id" => object_id} = data, %User{
897 when attributed_to == ap_id do
898 with {:ok, activity} <-
903 "actor" => attributed_to,
906 {:ok, Object.normalize(activity)}
908 _ -> get_obj_helper(object_id)
912 def get_embedded_obj_helper(object_id, _) do
913 get_obj_helper(object_id)
916 def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
917 with false <- String.starts_with?(in_reply_to, "http"),
918 {:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
919 Map.put(object, "inReplyTo", replied_to_object["external_url"] || in_reply_to)
925 def set_reply_to_uri(obj), do: obj
928 Serialized Mastodon-compatible `replies` collection containing _self-replies_.
929 Based on Mastodon's ActivityPub::NoteSerializer#replies.
931 def set_replies(obj_data) do
933 with limit when limit > 0 <-
934 Pleroma.Config.get([:activitypub, :note_replies_output_limit], 0),
935 %Object{} = object <- Object.get_cached_by_ap_id(obj_data["id"]) do
937 |> Object.self_replies()
938 |> select([o], fragment("?->>'id'", o.data))
945 set_replies(obj_data, replies_uris)
948 defp set_replies(obj, []) do
952 defp set_replies(obj, replies_uris) do
953 replies_collection = %{
954 "type" => "Collection",
955 "items" => replies_uris
958 Map.merge(obj, %{"replies" => replies_collection})
961 def replies(%{"replies" => %{"first" => %{"items" => items}}}) when not is_nil(items) do
965 def replies(%{"replies" => %{"items" => items}}) when not is_nil(items) do
969 def replies(_), do: []
971 # Prepares the object of an outgoing create activity.
972 def prepare_object(object) do
979 |> prepare_attachments
983 |> strip_internal_fields
984 |> strip_internal_tags
990 # internal -> Mastodon
993 def prepare_outgoing(%{"type" => activity_type, "object" => object_id} = data)
994 when activity_type in ["Create", "Listen"] do
997 |> Object.normalize()
1003 |> Map.put("object", object)
1004 |> Map.merge(Utils.make_json_ld_header())
1005 |> Map.delete("bcc")
1010 def prepare_outgoing(%{"type" => "Announce", "actor" => ap_id, "object" => object_id} = data) do
1013 |> Object.normalize()
1016 if Visibility.is_private?(object) && object.data["actor"] == ap_id do
1017 data |> Map.put("object", object |> Map.get(:data) |> prepare_object)
1019 data |> maybe_fix_object_url
1024 |> strip_internal_fields
1025 |> Map.merge(Utils.make_json_ld_header())
1026 |> Map.delete("bcc")
1031 # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
1032 # because of course it does.
1033 def prepare_outgoing(%{"type" => "Accept"} = data) do
1034 with follow_activity <- Activity.normalize(data["object"]) do
1036 "actor" => follow_activity.actor,
1037 "object" => follow_activity.data["object"],
1038 "id" => follow_activity.data["id"],
1044 |> Map.put("object", object)
1045 |> Map.merge(Utils.make_json_ld_header())
1051 def prepare_outgoing(%{"type" => "Reject"} = data) do
1052 with follow_activity <- Activity.normalize(data["object"]) do
1054 "actor" => follow_activity.actor,
1055 "object" => follow_activity.data["object"],
1056 "id" => follow_activity.data["id"],
1062 |> Map.put("object", object)
1063 |> Map.merge(Utils.make_json_ld_header())
1069 def prepare_outgoing(%{"type" => _type} = data) do
1072 |> strip_internal_fields
1073 |> maybe_fix_object_url
1074 |> Map.merge(Utils.make_json_ld_header())
1079 def maybe_fix_object_url(%{"object" => object} = data) when is_binary(object) do
1080 with false <- String.starts_with?(object, "http"),
1081 {:fetch, {:ok, relative_object}} <- {:fetch, get_obj_helper(object)},
1082 %{data: %{"external_url" => external_url}} when not is_nil(external_url) <-
1084 Map.put(data, "object", external_url)
1087 Logger.error("Couldn't fetch #{object} #{inspect(e)}")
1095 def maybe_fix_object_url(data), do: data
1097 def add_hashtags(object) do
1099 (object["tag"] || [])
1101 # Expand internal representation tags into AS2 tags.
1102 tag when is_binary(tag) ->
1104 "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
1105 "name" => "##{tag}",
1109 # Do not process tags which are already AS2 tag objects.
1110 tag when is_map(tag) ->
1114 Map.put(object, "tag", tags)
1117 def add_mention_tags(object) do
1118 {enabled_receivers, disabled_receivers} = Utils.get_notified_from_object(object)
1119 potential_receivers = enabled_receivers ++ disabled_receivers
1120 mentions = Enum.map(potential_receivers, &build_mention_tag/1)
1122 tags = object["tag"] || []
1123 Map.put(object, "tag", tags ++ mentions)
1126 defp build_mention_tag(%{ap_id: ap_id, nickname: nickname} = _) do
1127 %{"type" => "Mention", "href" => ap_id, "name" => "@#{nickname}"}
1130 def take_emoji_tags(%User{emoji: emoji}) do
1132 |> Enum.flat_map(&Map.to_list/1)
1133 |> Enum.map(&build_emoji_tag/1)
1136 # TODO: we should probably send mtime instead of unix epoch time for updated
1137 def add_emoji_tags(%{"emoji" => emoji} = object) do
1138 tags = object["tag"] || []
1140 out = Enum.map(emoji, &build_emoji_tag/1)
1142 Map.put(object, "tag", tags ++ out)
1145 def add_emoji_tags(object), do: object
1147 defp build_emoji_tag({name, url}) do
1149 "icon" => %{"url" => url, "type" => "Image"},
1150 "name" => ":" <> name <> ":",
1152 "updated" => "1970-01-01T00:00:00Z",
1157 def set_conversation(object) do
1158 Map.put(object, "conversation", object["context"])
1161 def set_sensitive(object) do
1162 tags = object["tag"] || []
1163 Map.put(object, "sensitive", "nsfw" in tags)
1166 def set_type(%{"type" => "Answer"} = object) do
1167 Map.put(object, "type", "Note")
1170 def set_type(object), do: object
1172 def add_attributed_to(object) do
1173 attributed_to = object["attributedTo"] || object["actor"]
1174 Map.put(object, "attributedTo", attributed_to)
1177 def prepare_attachments(object) do
1179 (object["attachment"] || [])
1180 |> Enum.map(fn data ->
1181 [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
1182 %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
1185 Map.put(object, "attachment", attachments)
1188 def strip_internal_fields(object) do
1190 |> Map.drop(Pleroma.Constants.object_internal_fields())
1193 defp strip_internal_tags(%{"tag" => tags} = object) do
1194 tags = Enum.filter(tags, fn x -> is_map(x) end)
1196 Map.put(object, "tag", tags)
1199 defp strip_internal_tags(object), do: object
1201 def perform(:user_upgrade, user) do
1202 # we pass a fake user so that the followers collection is stripped away
1203 old_follower_address = User.ap_followers(%User{nickname: user.nickname})
1207 where: ^old_follower_address in a.recipients,
1212 "array_replace(?,?,?)",
1214 ^old_follower_address,
1215 ^user.follower_address
1220 |> Repo.update_all([])
1223 def upgrade_user_from_ap_id(ap_id) do
1224 with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
1225 {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
1226 already_ap <- User.ap_enabled?(user),
1227 {:ok, user} <- upgrade_user(user, data) do
1228 if not already_ap do
1229 TransmogrifierWorker.enqueue("user_upgrade", %{"user_id" => user.id})
1234 %User{} = user -> {:ok, user}
1239 defp upgrade_user(user, data) do
1241 |> User.upgrade_changeset(data, true)
1242 |> User.update_and_set_cache()
1245 def maybe_fix_user_url(%{"url" => url} = data) when is_map(url) do
1246 Map.put(data, "url", url["href"])
1249 def maybe_fix_user_url(data), do: data
1251 def maybe_fix_user_object(data), do: maybe_fix_user_url(data)
1253 defp ensure_context_presence(%{"context" => context} = data) when is_binary(context),
1256 defp ensure_context_presence(%{"object" => object} = data) when is_binary(object) do
1257 with %{data: %{"context" => context}} when is_binary(context) <- Object.normalize(object) do
1258 {:ok, Map.put(data, "context", context)}
1261 {:error, :no_context}
1265 defp ensure_context_presence(_) do
1266 {:error, :no_context}
1269 defp ensure_recipients_presence(%{"to" => [_ | _], "cc" => [_ | _]} = data),
1272 defp ensure_recipients_presence(%{"object" => object} = data) do
1273 case Object.normalize(object) do
1274 %{data: %{"actor" => actor}} ->
1277 |> Map.put("to", [actor])
1278 |> Map.put("cc", data["cc"] || [])
1283 {:error, :no_object}
1290 defp ensure_recipients_presence(_) do
1291 {:error, :no_object}